package system

import (
	"fmt"
	"net/http"
	"strings"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/erpserver/biz"
	"management/internal/pkg/convertor"
	"management/internal/pkg/tpl"
	"management/internal/router/manage/util"
)

type RoleHandler interface {
	List(w http.ResponseWriter, r *http.Request)
	Add(w http.ResponseWriter, r *http.Request)
	AddChildren(w http.ResponseWriter, r *http.Request)
	Edit(w http.ResponseWriter, r *http.Request)
	Save(w http.ResponseWriter, r *http.Request)
	Data(w http.ResponseWriter, r *http.Request)
	Refresh(w http.ResponseWriter, r *http.Request)
	RebuildParentPath(w http.ResponseWriter, r *http.Request)
	RefreshRoleMenus(w http.ResponseWriter, r *http.Request)
	SetMenu(w http.ResponseWriter, r *http.Request)
}

type roleHandler struct {
	render tpl.Renderer
	biz    biz.IBiz
}

var _ RoleHandler = (*roleHandler)(nil)

func NewRoleHandler(render tpl.Renderer, biz biz.IBiz) *roleHandler {
	return &roleHandler{
		render: render,
		biz:    biz,
	}
}

func (h *roleHandler) List(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		h.render.HTML(w, r, "role/list.tmpl", nil)
	case http.MethodPost:
		var q dto.SearchDto
		q.SearchStatus = convertor.ConvertInt(r.PostFormValue("status"), 9999)
		q.SearchParentID = convertor.ConvertInt(r.PostFormValue("parentId"), 0)
		q.SearchName = r.PostFormValue("name")
		q.SearchID = convertor.ConvertInt[int64](r.PostFormValue("id"), 0)
		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
		res, count, err := h.biz.SystemV1().RoleBiz().List(r.Context(), q)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := tpl.ResponseList{
			Code:    0,
			Message: "ok",
			Count:   count,
			Data:    res,
		}
		h.render.JSON(w, data)
	default:
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
	}
}

func (h *roleHandler) Add(w http.ResponseWriter, r *http.Request) {
	h.render.HTML(w, r, "role/edit.tmpl", map[string]any{
		"Item": &db.SysRole{Sort: 6666},
	})
}

func (h *roleHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	parentID := convertor.QueryInt(vars, "parentID", 0)
	vm := &db.SysRole{ParentID: int32(parentID), Sort: 6666}
	h.render.HTML(w, r, "role/edit.tmpl", map[string]any{
		"Item": vm,
	})
}

func (h *roleHandler) Edit(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	id := convertor.QueryInt[int32](vars, "id", 0)
	vm := &db.SysRole{Sort: 6666}
	if id > 0 {
		vm, _ = h.biz.SystemV1().RoleBiz().Get(r.Context(), id)
	}
	h.render.HTML(w, r, "role/edit.tmpl", map[string]any{
		"Item": vm,
	})
}

func (h *roleHandler) Save(w http.ResponseWriter, r *http.Request) {
	id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
	name := r.PostFormValue("Name")
	parentID := convertor.ConvertInt[int32](r.PostFormValue("ParentID"), 0)
	displayName := r.PostFormValue("DisplayName")
	sort := convertor.ConvertInt[int32](r.PostFormValue("Sort"), 6666)
	status := convertor.ConvertInt[int32](r.PostFormValue("Status"), 0)

	ctx := r.Context()
	var parent *db.SysRole
	if parentID > 0 {
		var err error
		parent, err = h.biz.SystemV1().RoleBiz().Get(ctx, parentID)
		if err != nil {
			h.render.JSONERR(w, "父级节点错误")
			return
		}
	} else {
		parent = &db.SysRole{
			ID:         0,
			ParentID:   0,
			ParentPath: ",0,",
		}
	}

	if id == 0 {
		arg := &db.CreateSysRoleParams{
			Name:        name,
			DisplayName: displayName,
			Vip:         false,
			ParentID:    parent.ID,
			ParentPath:  fmt.Sprintf("%s,%d,", parent.ParentPath, parent.ID),
			Status:      status,
			Sort:        sort,
			CreatedAt:   time.Now(),
			UpdatedAt:   time.Now(),
		}
		_, err := h.biz.SystemV1().RoleBiz().Create(ctx, arg)
		if err != nil {
			if db.IsUniqueViolation(err) {
				h.render.JSONERR(w, "角色名称已存在")
				return
			}
			h.render.JSONERR(w, err.Error())
			return
		}

		h.render.JSONOK(w, "添加成功")
	} else {
		res, err := h.biz.SystemV1().RoleBiz().Get(ctx, id)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}
		arg := &db.UpdateSysRoleParams{
			ID:          res.ID,
			DisplayName: displayName,
			Status:      status,
			ParentID:    parent.ID,
			ParentPath:  fmt.Sprintf("%s,%d,", parent.ParentPath, parent.ID),
			Sort:        sort,
			UpdatedAt:   time.Now(),
		}
		_, err = h.biz.SystemV1().RoleBiz().Update(ctx, arg)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}

		h.render.JSONOK(w, "更新成功")
	}
}

func (h *roleHandler) Data(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	vars := r.URL.Query()
	t := vars.Get("type")
	if t == "tree" {
		res, err := h.biz.SystemV1().RoleBiz().Tree(ctx, 0)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}

		h.render.JSON(w, res)
		return
	} else if t == "xmselect_tree" {
		res, err := h.biz.SystemV1().RoleBiz().XmSelectTree(ctx, 0)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}

		h.render.JSON(w, res)
		return
	}
}

func (h *roleHandler) Refresh(w http.ResponseWriter, r *http.Request) {
	_, err := h.biz.SystemV1().RoleBiz().Refresh(r.Context())
	if err != nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	h.render.JSONOK(w, "刷新成功")
}

func (h *roleHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	err := h.biz.SystemV1().RoleBiz().RebuildParentPath(ctx)
	if err != nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	h.render.JSONOK(w, "重建成功")
}

func (h *roleHandler) RefreshRoleMenus(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	// 获取需要刷新的角色ID
	roleID := convertor.ConvertInt[int32](r.PostFormValue("roleID"), 0)
	sysRole, err := h.biz.SystemV1().RoleBiz().Get(ctx, int32(roleID))
	if err != nil || sysRole == nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	// 刷新角色菜单 (角色所拥有的菜单集合)
	_, err = h.biz.SystemV1().MenuBiz().SetOwnerListMenuByRoleID(ctx, sysRole.ID)
	if err != nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	// 刷新角色菜单 (角色所拥有的菜单集合)
	_, err = h.biz.SystemV1().MenuBiz().SetOwnerMapMenuByRoleID(ctx, sysRole.ID)
	if err != nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	// 刷新角色菜单树 (pear admin layui 使用的格式)
	_, err = h.biz.SystemV1().MenuBiz().SetRecursiveSysMenus(ctx, sysRole.ID)
	if err != nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	h.render.JSONOK(w, "刷新成功")
}

func (h *roleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		vars := r.URL.Query()
		id := convertor.QueryInt[int32](vars, "id", 0)
		vm := struct {
			Role  *db.SysRole
			Menus []*dto.SetMenuDto
		}{}
		if id > 0 {
			ctx := r.Context()
			var err error
			vm.Role, err = h.biz.SystemV1().RoleBiz().Get(ctx, id)
			if err == nil {
				vm.Menus, _ = h.biz.SystemV1().MenuBiz().SetMenuViewData(ctx, vm.Role.ID)
			}
		}

		h.render.HTML(w, r, "role/set_menu.tmpl", map[string]any{
			"Item": vm,
		})
	case http.MethodPost:
		id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
		menus := r.PostFormValue("roleMenu")

		if id == 0 {
			h.render.JSONERR(w, "角色异常, 请刷新重试")
			return
		}

		if len(menus) == 0 {
			h.render.JSONERR(w, "请选择菜单")
			return
		}

		ctx := r.Context()
		_, err := h.biz.SystemV1().RoleBiz().Get(ctx, id)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}

		menuArr := strings.Split(menus, ",")
		if len(menuArr) == 0 {
			h.render.JSONERR(w, "请选择菜单")
			return
		}

		var menuList []*db.SysMenu
		for _, v := range menuArr {
			menuID := util.ConvertInt(v, 0)
			if menuID > 0 {
				menu, err := h.biz.SystemV1().MenuBiz().Get(ctx, int32(menuID))
				if err != nil {
					h.render.JSONERR(w, err.Error())
					return
				}

				menuList = append(menuList, menu)
			}
		}

		if len(menuList) == 0 {
			h.render.JSONERR(w, "请选择正确的菜单")
			return
		}

		err = h.biz.SystemV1().MenuBiz().SetMenu(ctx, id, menuList)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}

		h.render.JSONOK(w, "设置成功")
	default:
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
	}
}