package client

import (
	"github.com/pkg/errors"
	"net/http"
)

const (
	createWorkflowTemplateRelativeUrl          = "/api/v1/workflow-templates/{namespace}"
	deleteWorkflowTemplateRelativeUrl          = "/api/v1/workflow-templates/{namespace}/{name}"
	updateWorkflowTemplateRelativeUrl          = "/api/v1/workflow-templates/{namespace}/{name}"
	getWorkflowTemplatesInNamespaceRelativeUrl = "/api/v1/workflow-templates/{namespace}"
	getWorkflowTemplateRelativeUrl             = "/api/v1/workflow-templates/{namespace}/{name}"
	lintWorkflowTemplateRelativeUrl            = "/api/v1/workflow-templates/{namespace}/lint"
)

type CreateWorkflowTemplateParams struct {
	Namespace          string
	TemplateDefinition map[string]any
}

func (c *Client) CreateWorkflowTemplate(params CreateWorkflowTemplateParams) error {
	responseMap := make(map[string]any)

	resp, err := c.restyClient.R().
		SetHeader("Content-Type", "application/json").
		SetAuthToken(c.token).
		SetPathParams(map[string]string{
			"namespace": params.Namespace,
		}).
		SetBody(map[string]any{
			"namespace": params.Namespace,
			"template":  params.TemplateDefinition,
		}).
		SetResult(&responseMap).
		SetError(&responseMap).
		Post(createWorkflowTemplateRelativeUrl)
	if err != nil {
		return errors.New(err.Error())
	}

	switch resp.StatusCode() {
	case http.StatusOK:
		return nil
	case http.StatusConflict:
		return errors.New("工作流模板已存在")
	default:
		message, ok := responseMap["message"]
		if !ok {
			return errors.Errorf("%v", resp.Status())
		}

		return errors.Errorf("%v, %v", resp.Status(), message)
	}
}

type DeleteWorkflowTemplateParams struct {
	Namespace string
	Name      string
}

func (c *Client) DeleteWorkflowTemplate(params DeleteWorkflowTemplateParams) error {
	responseMap := make(map[string]any)

	resp, err := c.restyClient.R().
		SetHeader("Content-Type", "application/json").
		SetAuthToken(c.token).
		SetPathParams(map[string]string{
			"namespace": params.Namespace,
			"name":      params.Name,
		}).
		SetResult(&responseMap).
		SetError(&responseMap).
		Delete(deleteWorkflowTemplateRelativeUrl)
	if err != nil {
		return errors.New(err.Error())
	}

	switch resp.StatusCode() {
	case http.StatusOK:
		return nil
	default:
		message, ok := responseMap["message"]
		if !ok {
			return errors.Errorf("%v", resp.Status())
		}

		return errors.Errorf("%v, %v", resp.Status(), message)
	}
}

type UpdateWorkflowTemplateParams struct {
	Namespace          string
	Name               string
	TemplateDefinition map[string]any
}

func (c *Client) UpdateWorkflowTemplate(params UpdateWorkflowTemplateParams) error {
	responseMap := make(map[string]any)

	resp, err := c.restyClient.R().
		SetHeader("Content-Type", "application/json").
		SetAuthToken(c.token).
		SetPathParams(map[string]string{
			"namespace": params.Namespace,
			"name":      params.Name,
		}).
		SetBody(map[string]any{
			"namespace": params.Namespace,
			"name":      params.Name,
			"template":  params.TemplateDefinition,
		}).
		SetResult(&responseMap).
		SetError(&responseMap).
		Put(updateWorkflowTemplateRelativeUrl)
	if err != nil {
		return errors.New(err.Error())
	}

	switch resp.StatusCode() {
	case http.StatusOK:
		return nil
	default:
		message, ok := responseMap["message"]
		if !ok {
			return errors.Errorf("%v", resp.Status())
		}

		return errors.Errorf("%v, %v", resp.Status(), message)
	}
}

type GetWorkflowTemplatesInNamespaceParams struct {
	Namespace string
}

func (c *Client) GetWorkflowTemplatesInNamespace(params GetWorkflowTemplatesInNamespaceParams) ([]map[string]any, error) {
	responseMap := make(map[string]any)

	resp, err := c.restyClient.R().
		SetHeader("Content-Type", "application/json").
		SetAuthToken(c.token).
		SetPathParams(map[string]string{
			"namespace": params.Namespace,
		}).
		SetResult(&responseMap).
		SetError(&responseMap).
		Get(getWorkflowTemplatesInNamespaceRelativeUrl)
	if err != nil {
		return nil, errors.New(err.Error())
	}

	switch resp.StatusCode() {
	case http.StatusOK:
		itemsValue, ok := responseMap["items"]
		if !ok {
			return nil, errors.New("没有获取到items参数")
		}

		items, ok := itemsValue.([]any)
		if !ok {
			return nil, errors.New("items不是slice")
		}

		templateDefinitions := make([]map[string]any, len(items))
		for i, item := range items {
			templateDefinition, ok := item.(map[string]any)
			if !ok {
				return nil, errors.New("item无法转换为map[string]any")
			}

			templateDefinitions[i] = templateDefinition
		}

		return templateDefinitions, nil
	default:
		message, ok := responseMap["message"]
		if !ok {
			return nil, errors.Errorf("%v", resp.Status())
		}

		return nil, errors.Errorf("%v, %v", resp.Status(), message)
	}
}

type GetWorkflowTemplateParams struct {
	Namespace string
	Name      string
}

func (c *Client) GetWorkflowTemplate(params GetWorkflowTemplateParams) (map[string]any, error) {
	responseMap := make(map[string]any)

	resp, err := c.restyClient.R().
		SetHeader("Content-Type", "application/json").
		SetAuthToken(c.token).
		SetPathParams(map[string]string{
			"namespace": params.Namespace,
			"name":      params.Name,
		}).
		SetResult(&responseMap).
		SetError(&responseMap).
		Get(getWorkflowTemplateRelativeUrl)
	if err != nil {
		return nil, errors.New(err.Error())
	}

	switch resp.StatusCode() {
	case http.StatusOK:
		return responseMap, nil
	default:
		message, ok := responseMap["message"]
		if !ok {
			return nil, errors.Errorf("%v", resp.Status())
		}

		return nil, errors.Errorf("%v, %v", resp.Status(), message)
	}
}

type LintWorkflowTemplateParams struct {
	Namespace          string
	TemplateDefinition map[string]any
}

func (c *Client) LintWorkflowTemplate(params LintWorkflowTemplateParams) error {
	responseMap := make(map[string]any)

	resp, err := c.restyClient.R().
		SetHeader("Content-Type", "application/json").
		SetAuthToken(c.token).
		SetPathParams(map[string]string{
			"namespace": params.Namespace,
		}).
		SetBody(map[string]any{
			"namespace": params.Namespace,
			"template":  params.TemplateDefinition,
		}).
		SetResult(&responseMap).
		SetError(&responseMap).
		Post(lintWorkflowTemplateRelativeUrl)
	if err != nil {
		return errors.New(err.Error())
	}

	switch resp.StatusCode() {
	case http.StatusOK:
		return nil
	case http.StatusConflict:
		return errors.New("工作流模板已存在")
	default:
		message, ok := responseMap["message"]
		if !ok {
			return errors.Errorf("%v", resp.Status())
		}

		return errors.Errorf("%v, %v", resp.Status(), message)
	}
}