package config

import (
	"encoding/json"
	"errors"
	"net/http"
	"strings"

	"management/internal/erpserver/model/dto"
	systemModel "management/internal/erpserver/model/system"
	"management/internal/erpserver/model/view"
	systemService "management/internal/erpserver/service/v1"
	"management/internal/erpserver/templ/system/config"
	"management/internal/pkg/convertor"
	"management/internal/pkg/render"
	"management/internal/pkg/sqldb"
)

type app struct {
	render        render.Renderer
	configService systemService.ConfigService
}

func newApp(render render.Renderer, configService systemService.ConfigService) *app {
	return &app{
		render:        render,
		configService: configService,
	}
}

func (a *app) list(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		ctx := r.Context()
		a.render.Render(ctx, w, config.List(ctx))
	case http.MethodPost:
		var q dto.SearchDto
		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
		q.SearchName = r.PostFormValue("name")
		q.Page = convertor.Int(r.PostFormValue("page"), 1)
		q.Rows = convertor.Int(r.PostFormValue("rows"), 10)
		ctx := r.Context()
		res, count, err := a.configService.List(ctx, q)
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}
		a.render.JSON(w, render.NewResponseList(count, res))
	default:
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
	}
}

func (a *app) add(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	a.render.Render(ctx, w, config.Edit(ctx, &view.EditSysConfig{Config: &systemModel.Config{}}))
}

func (a *app) edit(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	vars := r.URL.Query()
	id := convertor.QueryInt[int32](vars, "id", 0)
	vm := &view.EditSysConfig{}
	if id > 0 {
		if conf, err := a.configService.Get(r.Context(), id); err == nil {
			vm.Config = conf
			b, _ := json.Marshal(&conf.Value)
			vm.Result = string(b)
		}
	}
	a.render.Render(ctx, w, config.Edit(ctx, vm))
}

func (a *app) save(w http.ResponseWriter, r *http.Request) {
	id := convertor.Int[int32](r.PostFormValue("ID"), 0)
	key := r.PostFormValue("Key")
	value := r.PostFormValue("Value")
	if len(key) == 0 {
		a.render.JSONErr(w, "Key不能为空")
		return
	}
	if len(value) == 0 {
		a.render.JSONErr(w, "Value不能为空")
		return
	}

	ctx := r.Context()
	if id == 0 {
		arg := &systemModel.Config{
			Key:   key,
			Value: []byte(value),
		}
		err := a.configService.Create(ctx, arg)
		if err != nil {
			if errors.Is(err, sqldb.ErrDBDuplicatedEntry) {
				a.render.JSONErr(w, "数据已存在")
				return
			}
			a.render.JSONErr(w, err.Error())
			return
		}

		a.render.JSONOk(w, "添加成功")
	} else {
		res, err := a.configService.Get(ctx, id)
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}

		res.Value = []byte(value)
		err = a.configService.Update(ctx, res)
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}

		a.render.JSONOk(w, "更新成功")
	}
}

func (a *app) refreshCache(w http.ResponseWriter, r *http.Request) {
	key := r.FormValue("key")
	err := a.configService.RefreshCache(r.Context(), strings.ToLower(key))
	if err != nil {
		a.render.JSONErr(w, err.Error())
		return
	}

	a.render.JSONOk(w, "刷新成功")
}

func (a *app) resetPear(w http.ResponseWriter, r *http.Request) {
	err := a.configService.ResetPear(r.Context())
	if err != nil {
		a.render.JSONErr(w, err.Error())
		return
	}
	a.render.JSONOk(w, "重置成功")
}

func (a *app) pear(w http.ResponseWriter, r *http.Request) {
	pear, err := a.configService.Pear(r.Context())
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	a.render.JSON(w, pear)
}