package com.webmanage.controller;

import com.webmanage.common.Result;
import com.webmanage.dto.CreateOrderDTO;
import com.webmanage.dto.OrderQueryDTO;
import com.webmanage.entity.OrderInfo;
import com.webmanage.service.OrderInfoService;
import com.webmanage.service.TokenService;
import com.webmanage.service.OrderNoService;
import com.webmanage.vo.OrderDetailVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

/**
 * 订单管理Controller
 */
@Slf4j
@RestController
@RequestMapping("/api/order")
@Api(tags = "订单管理")
@Validated
public class OrderController {
    @Resource private OrderInfoService orderInfoService;
    @Resource private OrderNoService orderNoService;
    @Resource private TokenService tokenService;

    @PostMapping("/buyer/page")
    @ApiOperation("分页查询买家订单列表")
    public Result<Object> getBuyerOrderPage(@Valid @RequestBody OrderQueryDTO queryDTO) {
        try { return Result.success(orderInfoService.getBuyerOrderPage(queryDTO)); }
        catch (Exception e) { log.error("查询买家订单列表失败", e); return Result.error("查询买家订单列表失败：" + e.getMessage()); }
    }

    @PostMapping("/create")
    @ApiOperation("创建订单（包含订单详情），需在 Header 携带 Idempotency-Token 防重复提交")
    public Result<OrderInfo> createOrder(@RequestHeader(value = "Idempotency-Token", required = false) String token,
                                         @Valid @RequestBody CreateOrderDTO createOrderDTO) {
        try {
            if (!tokenService.verifyAndConsume(token)) {
                return Result.error("请求无效或重复提交，请刷新页面后重试");
            }
            OrderInfo orderInfo = orderInfoService.createOrder(createOrderDTO);
            return Result.success(orderInfo);
        } catch (Exception e) {
            log.error("创建订单失败", e);
            return Result.error("创建订单失败：" + e.getMessage());
        }
    }

    @GetMapping("/idempotency/token")
    @ApiOperation("获取一次性防重复提交 Token")
    public Result<Object> getIdempotencyToken(@RequestParam(required = false) Long userId) {
        try {
            String token = tokenService.generateToken(userId);
            return Result.success("token生成",token);
        } catch (Exception e) {
            log.error("生成防重复提交 Token 失败", e);
            return Result.error("生成防重复提交 Token 失败：" + e.getMessage());
        }
    }

    @GetMapping("/no/new")
    @ApiOperation("生成唯一订单号")
    public Result<Object> generateOrderNo() {
        try {
            String orderNo = orderNoService.generateOrderNo();
            return Result.success(orderNo);
        } catch (Exception e) {
            log.error("生成订单号失败", e);
            return Result.error("生成订单号失败：" + e.getMessage());
        }
    }

    @PostMapping("/seller/page")
    @ApiOperation("分页查询卖家订单列表")
    public Result<Object> getSellerOrderPage(@Valid @RequestBody OrderQueryDTO queryDTO) {
        try {
            if (queryDTO.getProviderId() == null) {
                return Result.error("提供者ID不能为空");
            }
            return Result.success(orderInfoService.getSellerOrderPage(queryDTO));
        } catch (Exception e) {
            log.error("查询卖家订单列表失败", e);
            return Result.error("查询卖家订单列表失败：" + e.getMessage());
        }
    }

    @PostMapping("/approval/page")
    @ApiOperation("分页查询待审批订单列表")
    public Result<Object> getPendingApprovalOrderPage(@Valid @RequestBody OrderQueryDTO queryDTO) {
        try {
            return Result.success(orderInfoService.getPendingApprovalOrderPage(queryDTO));
        } catch (Exception e) {
            log.error("查询待审批订单列表失败", e);
            return Result.error("查询待审批订单列表失败：" + e.getMessage());
        }
    }

    @GetMapping("/detail/{orderId}")
    @ApiOperation("获取订单详情")
    public Result<OrderDetailVO> getOrderDetail(
            @ApiParam("订单ID") @PathVariable @NotBlank String orderId) {
        try {
            OrderDetailVO orderDetail = orderInfoService.getOrderDetail(orderId);
            return Result.success(orderDetail);
        } catch (Exception e) {
            log.error("获取订单详情失败，订单ID: {}", orderId, e);
            return Result.error("获取订单详情失败：" + e.getMessage());
        }
    }

    @PostMapping("/attachment/upload")
    @ApiOperation("上传订单附件")
    public Result<Boolean> uploadOrderAttachment(
            @ApiParam("订单ID") @RequestParam @NotBlank String orderId,
            @ApiParam("文件名") @RequestParam @NotBlank String fileName,
            @ApiParam("原始文件名") @RequestParam String originalName,
            @ApiParam("附件类型") @RequestParam @NotBlank String fileType,
            @ApiParam("附件大小") @RequestParam @NotNull Long fileSize,
            @ApiParam("附件地址") @RequestParam @NotBlank String fileUrl,
            @ApiParam("存储桶名称") @RequestParam String bucketName,
            @ApiParam("对象名称") @RequestParam String objectName,
            @ApiParam("上传用户ID") @RequestParam @NotNull Long uploadUserId,
            @ApiParam("上传用户名") @RequestParam @NotBlank String uploadUserName,
            @ApiParam("附件类型") @RequestParam String attachmentType,
            @ApiParam("附件描述") @RequestParam String description) {
        try {
            boolean result = orderInfoService.uploadOrderAttachment(
                orderId, fileName, originalName, fileType, fileSize, fileUrl,
                bucketName, objectName, uploadUserId, uploadUserName, attachmentType, description
            );
            return result ? Result.success(true) : Result.error("上传订单附件失败");
        } catch (Exception e) {
            log.error("上传订单附件失败，订单ID: {}", orderId, e);
            return Result.error("上传订单附件失败：" + e.getMessage());
        }
    }

    @PostMapping("/evaluation/add")
    @ApiOperation("添加订单评价")
    public Result<Boolean> addOrderEvaluation(
            @ApiParam("订单ID") @RequestParam @NotBlank String orderId,
            @ApiParam("评价人ID") @RequestParam @NotNull Long evaluatorId,
            @ApiParam("评价人姓名") @RequestParam @NotBlank String evaluatorName,
            @ApiParam("评价人类型") @RequestParam @NotBlank String evaluatorType,
            @ApiParam("评价内容") @RequestParam @NotBlank String content,
            @ApiParam("评分") @RequestParam @NotNull Integer rating,
            @ApiParam("服务评分") @RequestParam Integer serviceRating,
            @ApiParam("质量评分") @RequestParam Integer qualityRating,
            @ApiParam("交付评分") @RequestParam Integer deliveryRating,
            @ApiParam("是否匿名") @RequestParam Boolean isAnonymous) {
        try {
            boolean result = orderInfoService.addOrderEvaluation(
                orderId, evaluatorId, evaluatorName, evaluatorType, content, rating,
                serviceRating, qualityRating, deliveryRating, isAnonymous
            );
            return result ? Result.success(true) : Result.error("添加订单评价失败");
        } catch (Exception e) {
            log.error("添加订单评价失败，订单ID: {}", orderId, e);
            return Result.error("添加订单评价失败：" + e.getMessage());
        }
    }

    @PostMapping("/transaction/confirm")
    @ApiOperation("交易确认")
    public Result<Boolean> confirmTransaction(
            @ApiParam("订单ID") @RequestParam @NotBlank String orderId,
            @ApiParam("用户ID") @RequestParam @NotNull Long userId) {
        try {
            boolean result = orderInfoService.confirmTransaction(orderId, userId);
            return result ? Result.success(true) : Result.error("交易确认失败");
        } catch (Exception e) {
            log.error("交易确认失败，订单ID: {}", orderId, e);
            return Result.error("交易确认失败：" + e.getMessage());
        }
    }

    @PostMapping("/evaluation/reply")
    @ApiOperation("回复评价")
    public Result<Boolean> replyEvaluation(
            @ApiParam("评价ID") @RequestParam @NotNull Long evaluationId,
            @ApiParam("回复内容") @RequestParam @NotBlank String replyContent,
            @ApiParam("回复用户ID") @RequestParam @NotNull Long replyUserId) {
        try {
            boolean result = orderInfoService.replyEvaluation(evaluationId, replyContent, replyUserId);
            return result ? Result.success(true) : Result.error("回复评价失败");
        } catch (Exception e) {
            log.error("回复评价失败，评价ID: {}", evaluationId, e);
            return Result.error("回复评价失败：" + e.getMessage());
        }
    }
}