package controller

import (
	"context"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"order/model/dto"
	"order/service"
)

// Order 订单控制器

type Order struct{}

var OrderController = &Order{}

// Create 创建订单
func (c *Order) Create(r *ghttp.Request) {
	ctx := r.Context()

	var req dto.CreateOrderReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析请求参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取订单服务实例
	orderService := service.GetOrderService()
	if orderService == nil {
		g.Log().Error(ctx, "订单服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 创建订单
	resp, err := orderService.CreateOrder(ctx, &req)
	if err != nil {
		g.Log().Error(ctx, "创建订单失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    resp,
	})
}

// Pay 支付订单
func (c *Order) Pay(r *ghttp.Request) {
	ctx := r.Context()

	var req dto.PayOrderReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析请求参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取支付服务实例
	paymentService := service.GetPaymentService()
	if paymentService == nil {
		g.Log().Error(ctx, "支付服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 支付订单
	resp, err := paymentService.PayOrder(ctx, &req)
	if err != nil {
		g.Log().Error(ctx, "支付订单失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    resp,
	})
}

// Query 查询订单详情
func (c *Order) Query(r *ghttp.Request) {
	ctx := r.Context()

	var req dto.QueryOrderReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析请求参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取订单服务实例
	orderService := service.GetOrderService()
	if orderService == nil {
		g.Log().Error(ctx, "订单服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 查询订单
	resp, err := orderService.QueryOrder(ctx, &req)
	if err != nil {
		g.Log().Error(ctx, "查询订单失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    resp,
	})
}

// Cancel 取消订单
func (c *Order) Cancel(r *ghttp.Request) {
	ctx := r.Context()

	var req dto.CancelOrderReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析请求参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取订单服务实例
	orderService := service.GetOrderService()
	if orderService == nil {
		g.Log().Error(ctx, "订单服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 取消订单
	resp, err := orderService.CancelOrder(ctx, &req)
	if err != nil {
		g.Log().Error(ctx, "取消订单失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    resp,
	})
}

// Refund 退款
func (c *Order) Refund(r *ghttp.Request) {
	ctx := r.Context()

	var req dto.RefundOrderReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析请求参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取支付服务实例
	paymentService := service.GetPaymentService()
	if paymentService == nil {
		g.Log().Error(ctx, "支付服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 退款
	resp, err := paymentService.RefundOrder(ctx, &req)
	if err != nil {
		g.Log().Error(ctx, "退款失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    resp,
	})
}

// List 查询订单列表
func (c *Order) List(r *ghttp.Request) {
	ctx := r.Context()

	var req dto.ListOrdersReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析请求参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取订单服务实例
	orderService := service.GetOrderService()
	if orderService == nil {
		g.Log().Error(ctx, "订单服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 查询订单列表
	resp, err := orderService.ListOrders(ctx, &req)
	if err != nil {
		g.Log().Error(ctx, "查询订单列表失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    resp,
	})
}

// PaymentNotify 支付回调
func (c *Order) PaymentNotify(r *ghttp.Request) {
	ctx := r.Context()

	var req service.PaymentNotifyReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析支付回调参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取支付服务实例
	paymentService := service.GetPaymentService()
	if paymentService == nil {
		g.Log().Error(ctx, "支付服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 处理支付回调
	if err := paymentService.HandlePaymentNotify(ctx, &req); err != nil {
		g.Log().Error(ctx, "处理支付回调失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    nil,
	})
}

// RefundNotify 退款回调
func (c *Order) RefundNotify(r *ghttp.Request) {
	ctx := r.Context()

	var req service.RefundNotifyReq
	if err := r.Parse(&req); err != nil {
		g.Log().Error(ctx, "解析退款回调参数失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    400,
			"message": "参数错误",
			"data":    nil,
		})
		return
	}

	// 获取支付服务实例
	paymentService := service.GetPaymentService()
	if paymentService == nil {
		g.Log().Error(ctx, "支付服务未初始化")
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": "服务内部错误",
			"data":    nil,
		})
		return
	}

	// 处理退款回调
	if err := paymentService.HandleRefundNotify(ctx, &req); err != nil {
		g.Log().Error(ctx, "处理退款回调失败:", err)
		r.Response.WriteJsonExit(g.Map{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	r.Response.WriteJson(g.Map{
		"code":    200,
		"message": "success",
		"data":    nil,
	})
}