package user

import (
	"net/http"

	"management/internal/erpserver/model/dto"
	"management/internal/erpserver/model/form"
	systemmodel "management/internal/erpserver/model/system"
	v1 "management/internal/erpserver/service/v1"
	"management/internal/erpserver/templ/system/user"
	"management/internal/pkg/binding"
	"management/internal/pkg/convertor"
	"management/internal/pkg/mid"
	"management/internal/pkg/render"
	"management/internal/pkg/session"

	"github.com/drhin/logger"
)

type App struct {
	log               *logger.Logger
	sm                session.Manager
	render            render.Renderer
	userService       v1.UserService
	roleService       v1.RoleService
	departmentService v1.DepartmentService
}

func NewApp(
	log *logger.Logger,
	sm session.Manager,
	render render.Renderer,
	userService v1.UserService,
	roleService v1.RoleService,
	departmentService v1.DepartmentService,
) *App {
	return &App{
		log:               log,
		sm:                sm,
		render:            render,
		userService:       userService,
		roleService:       roleService,
		departmentService: departmentService,
	}
}

func (a *App) add(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	a.render.Render(ctx, w, user.Edit(ctx, &systemmodel.User{HashedPassword: nil}))
}

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 := &systemmodel.User{}
	if id > 0 {
		if u, err := a.userService.Get(ctx, id); err == nil {
			vm.HashedPassword = []byte("********")
			vm = u
		}
	}
	a.render.Render(ctx, w, user.Edit(ctx, vm))
}

func (a *App) save(w http.ResponseWriter, r *http.Request) {
	var req form.User
	if err := binding.Form.Bind(r, &req); err != nil {
		a.render.JSONErr(w, binding.ValidatorErrors(err))
		return
	}

	ctx := r.Context()
	if req.DepartmentID > 0 {
		if _, err := a.departmentService.Get(ctx, req.DepartmentID); err != nil {
			a.render.JSONErr(w, "部门数据错误")
			return
		}
	}
	if req.RoleID > 0 {
		if _, err := a.roleService.Get(ctx, req.RoleID); err != nil {
			a.render.JSONErr(w, "角色数据错误")
			return
		}
	}

	if *req.ID == 0 {
		err := a.userService.Create(ctx, &req)
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}

		a.render.JSONOk(w, "添加成功")
	} else {
		err := a.userService.Update(ctx, &req)
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}

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

func (a *App) list(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		ctx := r.Context()
		a.render.Render(ctx, w, user.List(ctx))
	case http.MethodPost:
		var q dto.SearchDto
		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
		q.SearchStatus = convertor.ConvertInt(r.PostFormValue("status"), 9999)
		q.SearchName = r.PostFormValue("name")
		q.SearchEmail = r.PostFormValue("email")
		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 := a.userService.List(r.Context(), q)
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}

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

func (a *App) profile(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	u := mid.GetUser(ctx)
	vm, _ := a.userService.Get(ctx, u.ID)
	a.render.Render(ctx, w, user.Profile(ctx, vm))
}

func (a *App) data(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	t := vars.Get("type")
	if t == "xm_select" {
		res, err := a.userService.XmSelect(r.Context())
		if err != nil {
			a.render.JSONErr(w, err.Error())
			return
		}

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

	a.render.JSON(w, nil)
}