package sdk

import "context"

type ContextInfo struct {
	Period       any `json:"period"`
	Barpos       any `json:"barpos"`
	TimeTickSize any `json:"time_tick_size"`
	Stockcode    any `json:"stockcode"`
	DividendType any `json:"dividend_type"`
	Market       any `json:"market"`
	DoBackTest   any `json:"do_back_test"`
	Benchmark    any `json:"benchmark"`
	Capital      any `json:"capital"`
	Universe     any `json:"universe"`
}

func (c *Client) ContextPeriod(ctx context.Context) (any, error) {
	var out struct {
		Period any `json:"period"`
	}
	if err := c.get(ctx, "/api/context/period", &out); err != nil {
		return nil, err
	}
	return out.Period, nil
}

func (c *Client) ContextBarpos(ctx context.Context) (any, error) {
	var out struct {
		Barpos any `json:"barpos"`
	}
	if err := c.get(ctx, "/api/context/barpos", &out); err != nil {
		return nil, err
	}
	return out.Barpos, nil
}

func (c *Client) ContextTimeTickSize(ctx context.Context) (any, error) {
	var out struct {
		TimeTickSize any `json:"time_tick_size"`
	}
	if err := c.get(ctx, "/api/context/time_tick_size", &out); err != nil {
		return nil, err
	}
	return out.TimeTickSize, nil
}

func (c *Client) ContextStockcode(ctx context.Context) (any, error) {
	var out struct {
		Stockcode any `json:"stockcode"`
	}
	if err := c.get(ctx, "/api/context/stockcode", &out); err != nil {
		return nil, err
	}
	return out.Stockcode, nil
}

func (c *Client) ContextDividendType(ctx context.Context) (any, error) {
	var out struct {
		DividendType any `json:"dividend_type"`
	}
	if err := c.get(ctx, "/api/context/dividend_type", &out); err != nil {
		return nil, err
	}
	return out.DividendType, nil
}

func (c *Client) ContextMarket(ctx context.Context) (any, error) {
	var out struct {
		Market any `json:"market"`
	}
	if err := c.get(ctx, "/api/context/market", &out); err != nil {
		return nil, err
	}
	return out.Market, nil
}

func (c *Client) ContextDoBackTest(ctx context.Context) (any, error) {
	var out struct {
		DoBackTest any `json:"do_back_test"`
	}
	if err := c.get(ctx, "/api/context/do_back_test", &out); err != nil {
		return nil, err
	}
	return out.DoBackTest, nil
}

func (c *Client) ContextBenchmark(ctx context.Context) (any, error) {
	var out struct {
		Benchmark any `json:"benchmark"`
	}
	if err := c.get(ctx, "/api/context/benchmark", &out); err != nil {
		return nil, err
	}
	return out.Benchmark, nil
}

func (c *Client) ContextCapital(ctx context.Context) (any, error) {
	var out struct {
		Capital any `json:"capital"`
	}
	if err := c.get(ctx, "/api/context/capital", &out); err != nil {
		return nil, err
	}
	return out.Capital, nil
}

func (c *Client) ContextUniverse(ctx context.Context) ([]string, error) {
	var out struct {
		Universe any `json:"universe"`
	}
	if err := c.get(ctx, "/api/context/universe", &out); err != nil {
		return nil, err
	}
	switch v := out.Universe.(type) {
	case nil:
		return nil, nil
	case []any:
		codes := make([]string, 0, len(v))
		for _, item := range v {
			s := asString(item)
			if s != "" {
				codes = append(codes, s)
			}
		}
		return codes, nil
	case []string:
		return v, nil
	default:
		s := asString(v)
		if s == "" {
			return nil, nil
		}
		return []string{s}, nil
	}
}