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"
	"net/http"
	"strconv"
	"time"

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

func InitializeReportController(router *fiber.App) {
	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.Put("/report/:rid/step/meter/register", security.EnterpriseAuthorize, progressEndUserRegister)
	router.Post("/report/:rid/publish", security.EnterpriseAuthorize, publishReport)
	router.Get("/reports", security.MustAuthenticated, searchReports)
	router.Get("/report/:rid", security.MustAuthenticated, fetchReportPublicity)
	router.Post("/report/:rid/calculate", security.EnterpriseAuthorize, calculateReport)
}

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

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

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

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

func fetchReportParkSummary(c *fiber.Ctx) error {
	result := response.NewResult(c)
	requestReportId := c.Params("rid")
	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
		return err
	}
	summary, err := service.ReportService.RetreiveReportSummary(requestReportId)
	if err != nil {
		return result.NotFound(err.Error())
	}
	if summary == nil {
		return result.NotFound("指定报表未能找到。")
	}
	return result.Json(http.StatusOK, "已经获取到指定报表中的园区概况。", fiber.Map{"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 *fiber.Ctx) error {
	result := response.NewResult(c)
	requestReportId := c.Params("rid")
	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
		return err
	}
	formData := new(ReportSummaryFormData)
	if err := c.BodyParser(formData); err != nil {
		return result.UnableToParse("无法解析提交的数据。")
	}
	originSummary, err := service.ReportService.RetreiveReportSummary(requestReportId)
	if err != nil {
		return result.NotFound(err.Error())
	}
	copier.Copy(originSummary, formData)
	originSummary.ReportId = requestReportId
	err = service.ReportService.UpdateReportSummary(originSummary)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Updated("指定电费公示报表中的园区概况基本数据已经完成更新。")
}

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

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

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

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

func searchReports(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
		}
	}
	requestPeriodString := c.Query("period")
	var requestPeriod *time.Time = nil
	if len(requestPeriodString) > 0 {
		parsedPeriod, err := time.Parse("2006-01", requestPeriodString)
		if err != nil {
			return result.NotAccept("参数[period]的格式不正确。")
		}
		requestPeriod = lo.ToPtr(parsedPeriod)
	}
	requestKeyword := c.Query("keyword")
	requestPage, err := strconv.Atoi(c.Query("page", "1"))
	if err != nil {
		return result.NotAccept("查询参数[page]格式不正确。")
	}
	requestAllReports, err := strconv.ParseBool(c.Query("all", "false"))
	if err != nil {
		return result.NotAccept("查询参数[all]格式不正确。")
	}
	records, totalItems, err := service.ReportService.SearchReport(requestUser, requestPark, requestKeyword, requestPeriod, requestPage, !requestAllReports)
	if err != nil {
		return result.NotFound(err.Error())
	}
	return result.Success(
		"已经取得符合条件的公示报表记录。",
		response.NewPagedResponse(requestPage, totalItems).ToMap(),
		fiber.Map{"reports": records},
	)
}

func fetchReportPublicity(c *fiber.Ctx) error {
	result := response.NewResult(c)
	requestReportId := c.Params("rid")
	publicity, err := service.ReportService.AssembleReportPublicity(requestReportId)
	if err != nil {
		if nfErr, ok := err.(exceptions.NotFoundError); ok {
			return result.NotFound(nfErr.Error())
		} else {
			return result.Error(http.StatusInternalServerError, err.Error())
		}
	}
	return result.Success("已经取得指定公示报表的发布版本。", tools.ConvertStructToMap(publicity))
}

func calculateReport(c *fiber.Ctx) error {
	result := response.NewResult(c)
	requestReportId := c.Params("rid")
	if ensure, err := ensureReportBelongs(c, &result, requestReportId); !ensure {
		return err
	}
	err := service.CalculateService.ComprehensivelyCalculateReport(requestReportId)
	if err != nil {
		return result.Error(http.StatusInternalServerError, err.Error())
	}
	return result.Success("指定公示报表中的数据已经计算完毕。")
}