package controller

import (
	"electricity_bill_calc/model"
	"electricity_bill_calc/response"
	"electricity_bill_calc/security"
	"electricity_bill_calc/service"
	"net/http"
	"strconv"

	"github.com/gofiber/fiber/v2"
	"github.com/jinzhu/copier"
	"github.com/samber/lo"
	"github.com/shopspring/decimal"
)

func InitializeMaintenanceFeeController(router *fiber.App) {
	router.Get("/maintenance/fee", security.MustAuthenticated, listMaintenanceFees)
	router.Post("/maintenance/fee", security.EnterpriseAuthorize, createMaintenanceFeeRecord)
	router.Put("/maintenance/fee/:mid", security.EnterpriseAuthorize, modifyMaintenanceFeeRecord)
	router.Put("/maintenance/fee/:mid/enabled", security.EnterpriseAuthorize, changeMaintenanceFeeState)
	router.Delete("/maintenance/fee/:mid", security.EnterpriseAuthorize, deleteMaintenanceFee)
	router.Get("/additional/charges", security.MustAuthenticated, statAdditionalCharges)
}

func ensureMaintenanceFeeBelongs(c *fiber.Ctx, result *response.Result, requestMaintenanceFeeId string) (bool, error) {
	userSession, err := _retreiveSession(c)
	if err != nil {
		return false, result.Unauthorized(err.Error())
	}
	sure, err := service.MaintenanceFeeService.EnsureFeeBelongs(userSession.Uid, requestMaintenanceFeeId)
	if err != nil {
		return false, result.Error(http.StatusInternalServerError, err.Error())
	}
	if !sure {
		return false, result.Unauthorized("所操作维护费记录不属于当前用户。")
	}
	return true, nil
}

func listMaintenanceFees(c *fiber.Ctx) error {
	result := response.NewResult(c)
	userSession, err := _retreiveSession(c)
	if err != nil {
		return result.Unauthorized(err.Error())
	}
	requestPark := c.Query("park")
	requestPeriod := c.Query("period")
	requestPage, err := strconv.Atoi(c.Query("page", "1"))
	if err != nil {
		return result.Error(http.StatusInternalServerError, "不能解析给定的参数[page]。")
	}
	if len(requestPark) > 0 {
		if userSession.Type == model.USER_TYPE_ENT {
			if ensure, err := ensureParkBelongs(c, &result, requestPark); !ensure {
				return err
			}
		}
		fees, total, err := service.MaintenanceFeeService.ListMaintenanceFees([]string{requestPark}, requestPeriod, requestPage)
		if err != nil {
			return result.Error(http.StatusInternalServerError, err.Error())
		}
		return result.Json(
			http.StatusOK,
			"已获取指定园区下的维护费记录",
			response.NewPagedResponse(requestPage, total).ToMap(),
			fiber.Map{"fees": fees},
		)
	} else {
		parkIds, err := service.ParkService.AllParkIds(userSession.Uid)
		if err != nil {
			return result.Error(http.StatusInternalServerError, err.Error())
		}
		fees, total, err := service.MaintenanceFeeService.ListMaintenanceFees(parkIds, requestPeriod, requestPage)
		if err != nil {
			return result.Error(http.StatusInternalServerError, err.Error())
		}
		return result.Json(
			http.StatusOK,
			"已获取指定用户下的所有维护费记录。",
			response.NewPagedResponse(requestPage, total).ToMap(),
			fiber.Map{"fees": fees},
		)
	}
}

type _FeeCreationFormData struct {
	ParkId string          `json:"parkId" form:"parkId"`
	Name   string          `json:"name" form:"name"`
	Period string          `json:"period" form:"period"`
	Fee    decimal.Decimal `json:"fee" form:"fee"`
	Memo   *string         `json:"memo" form:"memo"`
}

func createMaintenanceFeeRecord(c *fiber.Ctx) error {
	result := response.NewResult(c)
	formData := new(_FeeCreationFormData)
	if err := c.BodyParser(formData); err != nil {
		return result.UnableToParse("无法解析提交的数据。")
	}
	if ensure, err := ensureParkBelongs(c, &result, formData.ParkId); !ensure {
		return err
	}
	newMaintenanceFee := &model.MaintenanceFee{}
	copier.Copy(newMaintenanceFee, formData)
	err := service.MaintenanceFeeService.CreateMaintenanceFeeRecord(*newMaintenanceFee)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Created("新维护费记录已经创建。")
}

type _FeeModificationFormData struct {
	Fee  decimal.Decimal `json:"fee" form:"fee"`
	Memo *string         `json:"memo" form:"memo"`
}

func modifyMaintenanceFeeRecord(c *fiber.Ctx) error {
	result := response.NewResult(c)
	requestFee := c.Params("mid")
	formData := new(_FeeModificationFormData)
	if err := c.BodyParser(formData); err != nil {
		return result.UnableToParse("无法解析提交的数据。")
	}
	if ensure, err := ensureMaintenanceFeeBelongs(c, &result, requestFee); !ensure {
		return err
	}
	newFeeState := new(model.MaintenanceFee)
	copier.Copy(newFeeState, formData)
	newFeeState.Id = requestFee
	err := service.MaintenanceFeeService.ModifyMaintenanceFee(*newFeeState)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("指定维护费条目已更新。")
}

type _FeeStateFormData struct {
	Enabled bool `json:"enabled" form:"enabled"`
}

func changeMaintenanceFeeState(c *fiber.Ctx) error {
	result := response.NewResult(c)
	requestFee := c.Params("mid")
	formData := new(_FeeStateFormData)
	if err := c.BodyParser(formData); err != nil {
		return result.UnableToParse("无法解析提交的数据。")
	}
	if ensure, err := ensureMaintenanceFeeBelongs(c, &result, requestFee); !ensure {
		return err
	}
	err := service.MaintenanceFeeService.ChangeMaintenanceFeeState(requestFee, formData.Enabled)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("指定维护费条目状态已更新。")
}

func deleteMaintenanceFee(c *fiber.Ctx) error {
	result := response.NewResult(c)
	requestFee := c.Params("mid")
	if ensure, err := ensureMaintenanceFeeBelongs(c, &result, requestFee); !ensure {
		return err
	}
	err := service.MaintenanceFeeService.DeleteMaintenanceFee(requestFee)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Deleted("指定维护费条目已删除。")
}

func statAdditionalCharges(c *fiber.Ctx) error {
	result := response.NewResult(c)
	session, err := _retreiveSession(c)
	if err != nil {
		return result.Unauthorized(err.Error())
	}
	requestUser := lo.
		If(session.Type == model.USER_TYPE_ENT, session.Uid).
		Else(c.Query("user"))
	requestPark := c.Query("park")
	if len(requestPark) > 0 && session.Type == model.USER_TYPE_ENT {
		if ensure, err := ensureParkBelongs(c, &result, requestPark); !ensure {
			return err
		}
	}
	period := c.Query("period", "")
	keyword := c.Query("keyword", "")
	requestPage, err := strconv.Atoi(c.Query("page", "1"))
	if err != nil {
		return result.Error(http.StatusInternalServerError, "不能解析给定的参数[page]。")
	}
	fees, total, err := service.MaintenanceFeeService.QueryAdditionalCharges(requestUser, requestPark, period, keyword, requestPage)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success(
		"已经成功获取到物业附加费的统计记录。",
		response.NewPagedResponse(requestPage, total).ToMap(),
		fiber.Map{"charges": fees},
	)
}