package client

import (
	"encoding/json"
	"fmt"
	"git.sxidc.com/go-tools/api_binding/http_binding/response"
	"net/url"
	"strconv"
)

const (
	executeRawSqlUrl = "/ds/api/v1/sql/rawSql/execute"
	parseSqlSpecUrl  = "/ds/api/v1/sql/spec/parse"
	createSqlUrl     = "/ds/api/v1/sql/create"
	deleteSqlUrl     = "/ds/api/v1/sql/delete"
	getSqlsUrl       = "/ds/api/v1/sql/query"
	executeSqlUrl    = "/ds/api/v1/sql/execute"
)

func (c *Client) ExecuteRawSql(token string, baseUrl string,
	namespace string, dataSource string, sql string, executeParams map[string]any) ([]map[string]any, error) {
	fullUrl, err := url.JoinPath(baseUrl, executeRawSqlUrl)
	if err != nil {
		return nil, err
	}

	resp := new(struct {
		response.MsgResponse
		Results []map[string]any `json:"results"`
	})

	err = c.post(token, fullUrl, map[string]any{
		"namespace":     namespace,
		"dataSource":    dataSource,
		"sql":           sql,
		"executeParams": executeParams,
	}, resp)
	if err != nil {
		return nil, err
	}

	if !resp.Success {
		return nil, fmt.Errorf(resp.Msg)
	}

	return resp.Results, nil
}

func (c *Client) ParseSqlSpec(token string, baseUrl string, spec map[string]any, executeParams map[string]any) (string, error) {
	fullUrl, err := url.JoinPath(baseUrl, parseSqlSpecUrl)
	if err != nil {
		return "", err
	}

	resp := new(struct {
		response.MsgResponse
		Parsed string `json:"parsed"`
	})

	specJsonBytes, err := json.Marshal(spec)
	if err != nil {
		return "", err
	}

	err = c.post(token, fullUrl, map[string]any{
		"sql":           string(specJsonBytes),
		"executeParams": executeParams,
	}, resp)
	if err != nil {
		return "", err
	}

	if !resp.Success {
		return "", fmt.Errorf(resp.Msg)
	}

	return resp.Parsed, nil
}

func (c *Client) CreateSql(token string, baseUrl string, namespace string, dataSource string, name string, spec map[string]any) error {
	fullUrl, err := url.JoinPath(baseUrl, createSqlUrl)
	if err != nil {
		return err
	}

	resp := new(response.MsgResponse)

	specJsonBytes, err := json.Marshal(spec)
	if err != nil {
		return err
	}

	err = c.post(token, fullUrl, map[string]any{
		"namespace":  namespace,
		"dataSource": dataSource,
		"name":       name,
		"sql":        string(specJsonBytes),
	}, resp)
	if err != nil {
		return err
	}

	if !resp.Success {
		return fmt.Errorf(resp.Msg)
	}

	return nil
}

func (c *Client) DeleteSql(token string, baseUrl string, namespace string, dataSource string, name string) error {
	fullUrl, err := url.JoinPath(baseUrl, deleteSqlUrl)
	if err != nil {
		return err
	}

	resp := new(response.MsgResponse)

	err = c.post(token, fullUrl, map[string]any{
		"namespace":  namespace,
		"dataSource": dataSource,
		"name":       name,
	}, resp)
	if err != nil {
		return err
	}

	if !resp.Success {
		return fmt.Errorf(resp.Msg)
	}

	return nil
}

func (c *Client) GetSqls(token string, baseUrl string, namespace string, dataSource string, name string, pageNo int, pageSize int) ([]SqlInfo, error) {
	fullUrl, err := url.JoinPath(baseUrl, getSqlsUrl)
	if err != nil {
		return nil, err
	}

	resp := new(response.InfosResponse[SqlInfo])

	err = c.get(token, fullUrl, map[string]string{
		"namespace":  namespace,
		"dataSource": dataSource,
		"name":       name,
		"pageNo":     strconv.Itoa(pageNo),
		"pageSize":   strconv.Itoa(pageSize),
	}, resp)
	if err != nil {
		return nil, err
	}

	if !resp.Success {
		return nil, fmt.Errorf(resp.Msg)
	}

	return resp.Infos, nil
}

func (c *Client) ExecuteSql(token string, baseUrl string,
	namespace string, dataSource string, name string, executeParams map[string]any) ([]map[string]any, error) {
	fullUrl, err := url.JoinPath(baseUrl, executeSqlUrl)
	if err != nil {
		return nil, err
	}

	resp := new(struct {
		response.MsgResponse
		Results []map[string]any `json:"results"`
	})

	err = c.post(token, fullUrl, map[string]any{
		"namespace":     namespace,
		"dataSource":    dataSource,
		"name":          name,
		"executeParams": executeParams,
	}, resp)
	if err != nil {
		return nil, err
	}

	if !resp.Success {
		return nil, fmt.Errorf(resp.Msg)
	}

	return resp.Results, nil
}