package payment

import (
	"strconv"

	"github.com/gin-gonic/gin"
	"wails-app/internal/dao"
	commonModel "wails-app/internal/model/common"
	"wails-app/internal/model/common/response"
	"wails-app/internal/model/vehicle/request"
	"wails-app/internal/modules/payment/repository"
	paymentService "wails-app/internal/modules/payment/service"
	utils "wails-app/internal/pkg"
	"wails-app/internal/service"
)

var vehicleSvc = service.ServiceGroupApp.VehicleServiceGroup.VehicleService
var paymentSvc = paymentService.NewPaymentService()

// ExitPreview 费用预览（只读，不修改数据库）
func ExitPreview(c *gin.Context) {
	var req request.ExitPreviewRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	resp, err := vehicleSvc.ExitPreview(req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(resp, c)
}

// OperationContext 返回车辆当前应执行的进场或出场操作上下文。
func OperationContext(c *gin.Context) {
	var req request.VehicleIdentityRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	resp, err := vehicleSvc.GetOperationContext(req)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(resp, c)
}

// HandlePassage 统一处理人工、UHF 和摄像头触发的进出场与开闸。
func HandlePassage(c *gin.Context) {
	var req commonModel.PassageRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	req.OperatorID = utils.GetUserID(c)
	result, err := service.ServiceGroupApp.ParkingServiceGroup.PassageService.HandlePassage(req)
	if err != nil {
		if result != nil {
			response.FailWithDetailed(result, err.Error(), c)
			return
		}
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(result, c)
}

// ExitConfirm 确认出场 + 支付
func ExitConfirm(c *gin.Context) {
	var req request.ExitConfirmRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	resp, err := vehicleSvc.ExitConfirm(req, utils.GetUserID(c))
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(resp, c)
}

// ListPayments 收费记录列表
func ListPayments(c *gin.Context) {
	var q repository.PaymentListQuery
	if err := c.ShouldBindQuery(&q); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	list, total, err := paymentSvc.QueryPayments(q)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithDetailed(response.PageResult{
		List:     list,
		Total:    total,
		Page:     q.Page,
		PageSize: q.PageSize,
	}, "查询成功", c)
}

// TodaySummary 当日收费汇总
func TodaySummary(c *gin.Context) {
	s, err := paymentSvc.GetTodaySummary()
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(s, c)
}

type methodStatusRequest struct {
	Enabled bool `json:"enabled"`
}

type methodOption struct {
	Code string `json:"code"`
	Name string `json:"name"`
}

type entryOption struct {
	Code string `json:"code"`
	Name string `json:"name"`
}

func ListMethods(c *gin.Context) {
	list, err := paymentSvc.ListMethods()
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(list, c)
}

func ListEnabledMethods(c *gin.Context) {
	entryCode := c.Query("entry")
	if entryCode == "" {
		// Accept the old query name during the transition so older clients keep
		// working while the API now exposes the concept as a payment entry.
		entryCode = c.Query("scene")
	}
	list, err := paymentSvc.ListEnabledMethods(entryCode)
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(list, c)
}

func ListMethodOptions(c *gin.Context) {
	list, err := paymentSvc.ListMethods()
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	options := make([]methodOption, 0, len(list)+1)
	for _, method := range list {
		options = append(options, methodOption{Code: method.Code, Name: method.Name})
	}
	options = append(options, methodOption{Code: paymentService.PaymentFree, Name: "免密放行"})
	response.OkWithData(options, c)
}

func ListEntries(c *gin.Context) {
	list, err := paymentSvc.ListEntries()
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(list, c)
}

func ListEnabledEntries(c *gin.Context) {
	list, err := paymentSvc.ListEnabledEntries()
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithData(list, c)
}

func ListEntryOptions(c *gin.Context) {
	list, err := paymentSvc.ListEnabledEntries()
	if err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	options := make([]entryOption, 0, len(list))
	for _, entry := range list {
		options = append(options, entryOption{Code: entry.Code, Name: entry.Name})
	}
	response.OkWithData(options, c)
}

func CreateMethod(c *gin.Context) {
	var req dao.PaymentMethodConfig
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := paymentSvc.CreateMethod(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("新增支付方式成功", c)
}

func UpdateMethod(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.FailWithMessage("无效的支付方式ID", c)
		return
	}
	var req dao.PaymentMethodConfig
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := paymentSvc.UpdateMethod(uint(id), &req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("更新支付方式成功", c)
}

func SetMethodStatus(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.FailWithMessage("无效的支付方式ID", c)
		return
	}
	var req methodStatusRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := paymentSvc.SetMethodEnabled(uint(id), req.Enabled); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("支付方式状态已更新", c)
}

func DeleteMethod(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.FailWithMessage("无效的支付方式ID", c)
		return
	}
	if err := paymentSvc.DeleteMethod(uint(id)); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("删除支付方式成功", c)
}

func CreateEntry(c *gin.Context) {
	var req dao.PaymentEntryConfig
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := paymentSvc.CreateEntry(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("新增支付入口成功", c)
}

func UpdateEntry(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.FailWithMessage("无效的支付入口ID", c)
		return
	}
	var req dao.PaymentEntryConfig
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := paymentSvc.UpdateEntry(uint(id), &req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("更新支付入口成功", c)
}

func SetEntryStatus(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.FailWithMessage("无效的支付入口ID", c)
		return
	}
	var req methodStatusRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	if err := paymentSvc.SetEntryEnabled(uint(id), req.Enabled); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("支付入口状态已更新", c)
}

func DeleteEntry(c *gin.Context) {
	id, err := strconv.ParseUint(c.Param("id"), 10, 64)
	if err != nil || id == 0 {
		response.FailWithMessage("无效的支付入口ID", c)
		return
	}
	if err := paymentSvc.DeleteEntry(uint(id)); err != nil {
		response.FailWithMessage(err.Error(), c)
		return
	}
	response.OkWithMessage("支付入口已删除", c)
}

// SetupPaymentRouter 注册支付相关路由
func SetupPaymentRouter(router *gin.RouterGroup) {
	pg := router.Group("/payment")
	{
		pg.GET("/list", ListPayments)
		pg.GET("/today-summary", TodaySummary)
		pg.GET("/methods", ListMethods)
		pg.GET("/methods/enabled", ListEnabledMethods)
		pg.GET("/methods/options", ListMethodOptions)
		pg.POST("/methods", CreateMethod)
		pg.PUT("/methods/:id", UpdateMethod)
		pg.PATCH("/methods/:id/status", SetMethodStatus)
		pg.DELETE("/methods/:id", DeleteMethod)
		pg.GET("/entries", ListEntries)
		pg.GET("/entries/enabled", ListEnabledEntries)
		pg.GET("/entries/options", ListEntryOptions)
		pg.POST("/entries", CreateEntry)
		pg.PUT("/entries/:id", UpdateEntry)
		pg.PATCH("/entries/:id/status", SetEntryStatus)
		pg.DELETE("/entries/:id", DeleteEntry)
	}
	eg := router.Group("/vehicle")
	{
		eg.POST("/operation/context", OperationContext)
		eg.POST("/passage", HandlePassage)
		eg.POST("/exit/preview", ExitPreview)
		eg.POST("/exit/confirm", ExitConfirm)
	}
}