package controller

import (
	"electricity_bill_calc/exceptions"
	"electricity_bill_calc/model"
	"electricity_bill_calc/response"
	"electricity_bill_calc/security"
	"electricity_bill_calc/service"
	"electricity_bill_calc/tools"
	"log"
	"net/http"
	"time"

	"github.com/fufuok/utils"
	"github.com/gin-gonic/gin"
	"github.com/jinzhu/copier"
	"github.com/samber/lo"
	"github.com/shopspring/decimal"
)

func InitializeReportController(router *gin.Engine) {
	router.GET("/reports/with/drafts", security.EnterpriseAuthorize, fetchNewestReportOfParkWithDraft)
	router.POST("/park/:pid/report", security.EnterpriseAuthorize, initializeNewReport)
	router.GET("/report/:rid/step/state", security.EnterpriseAuthorize, fetchReportStepStates)
	router.GET("/report/:rid/summary", security.EnterpriseAuthorize, fetchReportParkSummary)
	router.PUT("/report/:rid/summary", security.EnterpriseAuthorize, fillReportSummary)
	router.GET("/report/:rid/summary/calculate", security.EnterpriseAuthorize, testCalculateReportSummary)
	router.POST("/report/:rid/summary/calculate", security.EnterpriseAuthorize, progressReportSummary)
	router.GET("/report/:rid/maintenance", security.EnterpriseAuthorize, fetchWillDilutedFees)
	router.POST("/report/:rid/maintenance", security.EnterpriseAuthorize, createTemporaryWillDilutedFee)
	router.POST("/report/:rid/maintenance/import", security.EnterpriseAuthorize, importPredefinedMaintenanceFees)
	router.PUT("/report/:rid/maintenance/:mid", security.EnterpriseAuthorize, modifyWillDilutedFee)
	router.DELETE("/report/:rid/maintenance/:mid", security.EnterpriseAuthorize, deleteTemporaryWillDilutedFee)
	router.PUT("/report/:rid/step/diluted/fees", security.EnterpriseAuthorize, progressReportWillDilutedFee)
	router.PUT("/report/:rid/step/meter/register", security.EnterpriseAuthorize, progressEndUserRegister)
	router.POST("/report/:rid/publish", security.EnterpriseAuthorize, publishReport)
}

func ensureReportBelongs(c *gin.Context, result *response.Result, requestReportId string) bool {
	_, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return false
	}
	requestReport, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return false
	}
	if requestReport == nil {
		result.NotFound("指定报表未能找到。")
		return false
	}
	return ensureParkBelongs(c, result, requestReport.ParkId)
}

func fetchNewestReportOfParkWithDraft(c *gin.Context) {
	result := response.NewResult(c)
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	parks, err := service.ReportService.FetchParksWithNewestReport(userSession.Uid)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Json(http.StatusOK, "已获取到指定用户下所有园区的最新报表记录。", gin.H{"parks": parks})
}

func initializeNewReport(c *gin.Context) {
	result := response.NewResult(c)
	requestParkId := c.Param("pid")
	userSession, err := _retreiveSession(c)
	if err != nil {
		result.Unauthorized(err.Error())
		return
	}
	if !ensureParkBelongs(c, result, requestParkId) {
		return
	}
	requestPeriod := c.Query("period")
	reportPeriod, err := time.Parse("2006-01", requestPeriod)
	if err != nil {
		result.NotAccept("提供的初始化期数格式不正确。")
		return
	}
	valid, err := service.ReportService.IsNewPeriodValid(userSession.Uid, reportPeriod)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	if !valid {
		result.NotAccept("只能初始化已发布报表下一个月份的新报表。")
		return
	}
	newId, err := service.ReportService.InitializeNewReport(requestParkId, reportPeriod)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Created("新一期报表初始化成功。", gin.H{"reportId": newId})
}

func fetchReportStepStates(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	requestReport, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	result.Json(http.StatusOK, "已经获取到指定报表的填写状态。", gin.H{"steps": requestReport.StepState})
}

func fetchReportParkSummary(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	if summary == nil {
		result.NotFound("指定报表未能找到。")
		return
	}
	result.Json(http.StatusOK, "已经获取到指定报表中的园区概况。", gin.H{"summary": summary})
}

type ReportSummaryFormData struct {
	Overall     decimal.Decimal `json:"overall" form:"overall"`
	OverallFee  decimal.Decimal `json:"overallFee" form:"overallFee"`
	Critical    decimal.Decimal `json:"critical" form:"critical"`
	CriticalFee decimal.Decimal `json:"criticalFee" form:"criticalFee"`
	Peak        decimal.Decimal `json:"peak" form:"peak"`
	PeakFee     decimal.Decimal `json:"peakFee" form:"peakFee"`
	Valley      decimal.Decimal `json:"valley" form:"valley"`
	ValleyFee   decimal.Decimal `json:"valleyFee" form:"valleyFee"`
	BasicFee    decimal.Decimal `json:"basicFee" form:"basicFee"`
	AdjustFee   decimal.Decimal `json:"adjustFee" from:"adjustFee"`
}

func fillReportSummary(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	formData := new(ReportSummaryFormData)
	c.BindJSON(formData)
	originSummary, err := service.ReportService.RetreiveReportSummary(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	copier.Copy(originSummary, formData)
	err = service.ReportService.UpdateReportSummary(originSummary)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Updated("指定电费公示报表中的园区概况基本数据已经完成更新。")
}

func testCalculateReportSummary(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	summary.CalculatePrices()
	calcResults := tools.ConvertStructToMap(summary)
	result.Json(http.StatusOK, "已完成园区概况的试计算。", gin.H{"result": lo.PickByKeys(calcResults, []string{"overallPrice", "criticalPrice", "peakPrice", "flat", "flatFee", "flatPrice", "valleyPrice"})})
}

func progressReportSummary(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	err := service.ReportService.CalculateSummaryAndFinishStep(requestReportId)
	if err != nil {
		if nfErr, ok := err.(exceptions.NotFoundError); ok {
			result.NotFound(nfErr.Error())
		} else {
			result.Error(http.StatusInternalServerError, err.Error())
		}
		return
	}
	result.Success("已经完成园区概况的计算，并可以进行到下一步骤。")
}

func fetchWillDilutedFees(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	fees, err := service.ReportService.FetchWillDulutedMaintenanceFees(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	result.Json(http.StatusOK, "待摊薄费用已经获取到。", gin.H{"fees": fees})
}

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

func createTemporaryWillDilutedFee(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	formData := new(DilutedFeeCreationFormData)
	c.BindJSON(formData)
	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	if formData.ParkId != report.ParkId {
		result.NotAccept("选择的园区与公示报表所属的园区不一致。")
		return
	}
	newWillDilutedFee := new(model.WillDilutedFee)
	copier.Copy(newWillDilutedFee, formData)
	newWillDilutedFee.ReportId = report.Id
	err = service.ReportService.CreateTemporaryWillDilutedMaintenanceFee(*newWillDilutedFee)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Created("公示报表中所要使用的临时待摊薄费用已添加。")
}

func importPredefinedMaintenanceFees(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	maintenanceFees, err := service.MaintenanceFeeService.ListMaintenanceFees([]string{report.ParkId})
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	log.Printf("[cotroller] [debug] fees: %+v", maintenanceFees)
	enabledMaintenanceFees := lo.Filter(
		maintenanceFees,
		func(elem model.MaintenanceFee, index int) bool {
			return elem.Enabled
		},
	)
	log.Printf("[cotroller] [debug] fees: %+v", enabledMaintenanceFees)
	if len(enabledMaintenanceFees) == 0 {
		result.NotFound("没有找到可供导入的配电维护费记录。")
		return
	}
	dilutedFees := lo.Map(
		enabledMaintenanceFees,
		func(elem model.MaintenanceFee, index int) model.WillDilutedFee {
			fee := &model.WillDilutedFee{
				Id:       utils.UUIDString(),
				ReportId: report.Id,
				SourceId: lo.ToPtr(elem.Id),
				Name:     elem.Name,
				Fee:      elem.Fee,
				Memo:     elem.Memo,
			}
			return *fee
		},
	)
	err = service.ReportService.BatchSaveMaintenanceFee(report.Id, dilutedFees)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Created("预定义的配电维护费已经导入。")
}

type DilutedFeeModificationFormData struct {
	Name *string         `json:"name,omitempty" form:"name"`
	Fee  decimal.Decimal `json:"fee" form:"fee"`
	Memo *string         `json:"memo,omitempty" form:"memo"`
}

func modifyWillDilutedFee(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	requestFeeId := c.Param("mid")
	formData := new(DilutedFeeModificationFormData)
	c.BindJSON(formData)
	updateValues := tools.ConvertStructToMap(formData)
	err := service.ReportService.UpdateMaintenanceFee(requestFeeId, updateValues)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Updated("指定待摊薄费用信息已经更新。")
}

func deleteTemporaryWillDilutedFee(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	requestFeeId := c.Param("mid")
	err := service.ReportService.DeleteWillDilutedFee(requestFeeId)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Deleted("指定待摊薄费用信息已经删除。")
}

func progressReportWillDilutedFee(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	err = service.ReportService.ProgressReportWillDilutedFee(*report)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Success("待摊薄费用编辑步骤已经完成。")
}

func progressEndUserRegister(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	err = service.ReportService.ProgressReportRegisterEndUser(*report)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Success("终端用户抄表编辑步骤已经完成。")
}

func publishReport(c *gin.Context) {
	result := response.NewResult(c)
	requestReportId := c.Param("rid")
	if !ensureReportBelongs(c, result, requestReportId) {
		return
	}
	report, err := service.ReportService.RetreiveReportIndex(requestReportId)
	if err != nil {
		result.NotFound(err.Error())
		return
	}
	err = service.ReportService.PublishReport(*report)
	if err != nil {
		result.Error(http.StatusInternalServerError, err.Error())
		return
	}
	result.Success("指定的公示报表已经发布。")
}