package atapi

import (
	"fmt"
	"gitee.com/captials-team/ubdframe/src/common/utils"
	"gitee.com/captials-team/ubdframe/src/pkg/atapi/config"
	v1 "gitee.com/captials-team/ubdframe/src/pkg/atapi/httpapi/v1"
	"gitee.com/captials-team/ubdframe/src/pkg/atapi/httpapi/v1/plugins"
	"gitee.com/captials-team/ubdframe/src/pkg/atapi/ifs"
	"gitee.com/captials-team/ubdframe/src/pkg/codec"
	logv1 "gitee.com/captials-team/ubdframe/src/pkg/logs"
	"github.com/gin-gonic/gin"
	"github.com/go-openapi/spec"
	"io/ioutil"
	"strings"
)

type pluginFunc func(map[string]string) ifs.IApiPlugin

// AtApisManager at apis管理器
type AtApisManager struct {
	//配置
	config *config.AutoApiConfig

	//数据存储器
	store ifs.IAutoApiDataExec

	//格式化器
	format *codec.JsonCodec

	//所有atapis
	httpApis map[string]ifs.IAutoApi

	extraPlugins []pluginFunc

	logv1.InvokeLog
}

func NewAtApisManager(config *config.AutoApiConfig, opts ...interface{}) *AtApisManager {
	mag := &AtApisManager{
		httpApis: map[string]ifs.IAutoApi{},
		config:   config,
	}

	for _, v := range opts {
		if tmp, ok := v.(ifs.IAutoApiDataExec); ok {
			mag.store = tmp
		}
		if tmp, ok := v.(logv1.ILog); ok {
			mag.AddLogger(tmp)
		}
	}
	mag.format = &codec.JsonCodec{}
	return mag
}

func (mag *AtApisManager) SetDataExec(store ifs.IAutoApiDataExec) {
	mag.store = store
}

func (mag *AtApisManager) AddPlugin(f pluginFunc) {
	mag.extraPlugins = append(mag.extraPlugins, f)
}

func (mag *AtApisManager) Initial() error {
	for _, def := range mag.config.Apis {
		var api config.AutoApiDefined = def

		if def.LoadFile != "" {
			tmp, err := mag.readApiPath(def.LoadFile)
			if err != nil {
				return err
			}
			api = tmp
		}

		//基本信息
		mag.Info("=====> API: %s-%s, Version: %s", api.Name, api.ShowName, api.Version)
		apiHandler, err := mag.newAutoApi(api)
		if err != nil {
			mag.Error("at_api init fail: %s,%s", apiHandler.Code(), err)
			continue
		}
		mag.httpApis[apiHandler.Code()] = apiHandler
		mag.Info("%s loaded, handler: %s", api.Name, apiHandler.Code())
	}
	return nil
}

func (mag *AtApisManager) StartByGin(g gin.IRouter) error {
	for _, v := range mag.httpApis {
		mag.Info("%s start", v.Code())
		handlers := v.Handlers()
		for _, h := range handlers {
			if h.Method != "" && len(h.HandlerFunc) > 0 {
				g.Handle(h.Method, h.Path, h.HandlerFunc...)
				mag.Info("register router: %s,%s", h.Method, h.Path)
			}
		}
	}
	return nil
}

func (mag *AtApisManager) StartBySwagger(w *spec.Swagger) error {
	if w.Paths == nil {
		w.Paths = &spec.Paths{}
	}
	if w.Definitions == nil {
		w.Definitions = spec.Definitions{}
	}
	if w.Paths.Paths == nil {
		w.Paths.Paths = make(map[string]spec.PathItem)
	}
	for _, api := range mag.httpApis {
		handlers := api.Handlers()
		mag.Info("%s swagger len=%d", api.Code(), len(handlers))
		for _, h := range handlers {
			//合并swagger
			if h.SwaggerPaths != nil {
				for k, v := range h.SwaggerPaths {
					w.Paths.Paths[k] = v
					mag.Info("\tadd swagger path: %s", k)
				}
			}
			if h.SwaggerDefinitions != nil {
				for k, v := range h.SwaggerDefinitions {
					w.Definitions[k] = v
					mag.Info("\tadd swagger definition: %s", k)
				}
			}
		}
	}
	return nil
}

func (mag *AtApisManager) newAutoApi(api config.AutoApiDefined) (ifs.IAutoApi, error) {
	switch strings.ToLower(api.Version) {
	case v1.Version:
		return mag.newAutoApiV1(api)
	default:
		return mag.newAutoApiV1(api)
	}
}

func (mag *AtApisManager) newAutoApiV1(apiDef config.AutoApiDefined) (*v1.AutoApi, error) {
	api, err := v1.NewAutoApi(apiDef, mag.config.ExtendParams)
	if err != nil {
		return nil, fmt.Errorf("at_api new fail: %s", err)
	}
	api.SetDataExec(mag.store.Copy())
	//api.SetVars(vars)
	//内置plugin
	api.AddPlugin(
		plugins.NewRateLimitPlugin(),
		plugins.NewJWTAuthorizePlugin(),
	)
	api.AddPlugin(
		plugins.NewApiSearchPlugin(),
		plugins.NewApiQueryPlugin(),
		plugins.NewApiCreatePlugin(),
		plugins.NewApiUpdatePlugin(),
		plugins.NewApiDeletePlugin(),
		plugins.NewApiResponsePlugin(),
	)
	//自定义插件
	for _, tmp := range mag.extraPlugins {
		api.AddPlugin(tmp(mag.config.ExtendParams))
	}

	if err := api.Init(); err != nil {
		return nil, err
	}

	return api, nil
}

func (mag *AtApisManager) readApiPath(path string) (config.AutoApiDefined, error) {
	vars := mag.config.ExtendParams
	var c config.AutoApiDefined

	content, err := ioutil.ReadFile(path)
	if err != nil {
		return c, err
	}

	//替换变量
	if vars != nil {
		s := string(content)
		for k, v := range vars {
			s = strings.Replace(s, fmt.Sprintf("{{%s}}", k), v, -1)
		}
		content = []byte(s)
	}

	err = utils.ReadYamlFile(&c, path)
	if err != nil {
		return c, err
	}

	return c, nil
}