package budget

import (
	"errors"
	"net/http"
	"strconv"
	"strings"
	"time"

	"management/internal/db/model/form"
	db "management/internal/db/sqlc"
	"management/internal/erpserver/biz"
	"management/internal/pkg/convertor"
	"management/internal/pkg/know"
	"management/internal/pkg/middleware"
	"management/internal/pkg/tpl"
	"management/internal/pkg/tpl/html"

	"github.com/jackc/pgx/v5/pgtype"
)

type BudgetHandler interface {
	List(w http.ResponseWriter, r *http.Request)
	Add(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)
}

type budgetHandler struct {
	render tpl.Renderer
	biz    biz.IBiz
	mi     middleware.IMiddleware
}

var _ BudgetHandler = (*budgetHandler)(nil)

func NewBudgetHandler(render tpl.Renderer, biz biz.IBiz, mi middleware.IMiddleware) *budgetHandler {
	return &budgetHandler{
		render: render,
		biz:    biz,
		mi:     mi,
	}
}

func (h *budgetHandler) List(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		ctx := r.Context()
		pp, _ := h.biz.ProjectV1().ListHtml(ctx)
		cc, _ := h.biz.SystemV1().CategoryBiz().ListHtmlByLetter(ctx, know.BudgetCategory)
		h.render.HTML(w, r, "budget/list.tmpl", map[string]any{
			"Statuses":   html.NewSelectControls(html.Statuses, "0"),
			"Projects":   html.NewSelectControls(pp, "0"),
			"Categories": html.NewSelectControls(cc, "0"),
		})
	case http.MethodPost:
		ctx := r.Context()
		project := convertor.ConvertInt[int64](r.PostFormValue("project"), 9999)
		if project == 0 {
			project = 9999
		}

		budgetType := convertor.ConvertInt[int32](r.PostFormValue("budgetType"), 9999)
		if budgetType == 0 {
			budgetType = 9999
		}

		category := convertor.ConvertInt[int32](r.PostFormValue("category"), 9999)
		if category == 0 {
			category = 9999
		}

		title := strings.TrimSpace(r.PostFormValue("title"))
		var search string
		if len(title) > 0 {
			search = "%" + title + "%"
			if strings.HasSuffix(title, ":") {
				search = title[:len(title)-1] + "%"
			}
		}
		arg := &db.ListBudgetConditionParam{
			ProjectID:  project,
			BudgetType: budgetType,
			Category:   category,
			IsTitle:    len(search) > 0,
			Title:      search,
			Status:     convertor.ConvertInt[int16](r.PostFormValue("status"), 9999),
			PageID:     convertor.ConvertInt[int32](r.PostFormValue("page"), 1),
			PageSize:   convertor.ConvertInt[int32](r.PostFormValue("rows"), 10),
		}
		arg.TimeBegin, arg.TimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
		res, total, err := h.biz.BudgetV1().List(ctx, arg)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}

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

func (h *budgetHandler) Add(w http.ResponseWriter, r *http.Request) {
	h.render.HTML(w, r, "budget/edit.tmpl", map[string]any{
		"Item": &form.BudgetForm{
			BudgetType: 1,
		},
		"Statuses": html.NewSelectControls(html.Statuses, "0"),
	})
}

func (h *budgetHandler) Edit(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	id := convertor.QueryInt[int64](vars, "id", 0)
	budget := &form.BudgetForm{}
	ctx := r.Context()
	if id > 0 {
		if cus, err := h.biz.BudgetV1().Get(ctx, id); err == nil {
			budget = budget.ToForm(cus)
			if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.CreatedUserID); err == nil {
				budget.CreatedName = u.Username
			}
			if u, err := h.biz.SystemV1().UserBiz().Get(ctx, cus.UpdatedUserID); err == nil {
				budget.UpdatedName = u.Username
			}
		}
	}
	h.render.HTML(w, r, "budget/edit.tmpl", map[string]any{
		"Item":     budget,
		"Statuses": html.NewSelectControls(html.Statuses, strconv.Itoa(int(budget.Status))),
	})
}

func (h *budgetHandler) Save(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	data, err := validForm(r)
	if err != nil {
		h.render.JSONERR(w, err.Error())
		return
	}

	authUser := h.mi.AuthUser(ctx)
	if data.ID > 0 {
		arg := &db.UpdateBudgetParams{
			ID: data.ID,
			ProjectID: pgtype.Int8{
				Int64: data.ProjectID,
				Valid: true,
			},
			Name: pgtype.Text{
				String: data.Name,
				Valid:  true,
			},
			BudgetType: pgtype.Int4{
				Int32: data.BudgetType,
				Valid: true,
			},
			Category: pgtype.Int4{
				Int32: data.Category,
				Valid: true,
			},
			StartAt: pgtype.Timestamptz{
				Time:  data.StartAt,
				Valid: true,
			},
			EndAt: pgtype.Timestamptz{
				Time:  data.EndAt,
				Valid: true,
			},
			Amount:          data.AmountF,
			UsedAmount:      data.UsedAmountF,
			RemainingAmount: data.RemainingAmountF,
			Remark: pgtype.Text{
				String: data.Remark,
				Valid:  true,
			},
			Status: pgtype.Int2{
				Int16: data.Status,
				Valid: true,
			},
			UpdatedUserID: pgtype.Int4{
				Int32: authUser.ID,
				Valid: true,
			},
		}
		_, err := h.biz.BudgetV1().Update(ctx, arg)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}
		h.render.JSONOK(w, "更新成功")
	} else {
		arg := &db.CreateBudgetParams{
			ProjectID:       data.ProjectID,
			Name:            data.Name,
			BudgetType:      data.BudgetType,
			Category:        data.Category,
			StartAt:         data.StartAt,
			EndAt:           data.EndAt,
			Amount:          data.AmountF,
			UsedAmount:      data.UsedAmountF,
			RemainingAmount: data.RemainingAmountF,
			Remark:          data.Remark,
			CreatedUserID:   authUser.ID,
		}
		_, err := h.biz.BudgetV1().Create(ctx, arg)
		if err != nil {
			h.render.JSONERR(w, err.Error())
			return
		}
		h.render.JSONOK(w, "添加成功")
	}
}

func (h *budgetHandler) Data(w http.ResponseWriter, r *http.Request) {}

func validForm(r *http.Request) (form.BudgetForm, error) {
	var err error
	data := form.BudgetForm{}

	data.ID = convertor.ConvertInt[int64](r.PostFormValue("ID"), 0)
	data.ProjectID, err = strconv.ParseInt(r.PostFormValue("ProjectID"), 10, 64)
	if err != nil || data.ProjectID == 0 {
		return data, errors.New("项目不能为空")
	}

	data.Name = r.PostFormValue("Name")
	if len(data.Name) == 0 {
		return data, errors.New("预算名称不能为空")
	}

	budgetType, err := strconv.ParseInt(r.PostFormValue("BudgetType"), 10, 32)
	if err != nil {
		return data, errors.New("预算类型不能为空")
	}
	data.BudgetType = int32(budgetType)

	category, err := strconv.ParseInt(r.PostFormValue("Category"), 10, 32)
	if err != nil {
		return data, errors.New("预算类别不能为空")
	}
	data.Category = int32(category)

	data.StartAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("StartAt"), time.Local)
	if err != nil {
		return data, errors.New("开始时间格式错误")
	}
	data.EndAt, err = time.ParseInLocation("2006-01-02", r.PostFormValue("EndAt"), time.Local)
	if err != nil {
		return data, errors.New("结束时间格式错误")
	}

	if err := data.AmountF.Scan(r.PostFormValue("Amount")); err != nil {
		return data, errors.New("预算金额格式错误")
	}
	if err := data.UsedAmountF.Scan(r.PostFormValue("UsedAmount")); err != nil {
		return data, errors.New("已支付金额格式错误")
	}
	if err := data.RemainingAmountF.Scan(r.PostFormValue("RemainingAmount")); err != nil {
		return data, errors.New("剩余金额格式错误")
	}

	data.Remark = r.PostFormValue("Remark")
	data.Status = convertor.ConvertInt[int16](r.PostFormValue("Status"), 9999)
	return data, nil
}