package com.fs.company.controller.live;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSONObject;
import com.fs.common.annotation.Log;
import com.fs.common.constant.HttpStatus;
import com.fs.common.core.controller.BaseController;
import com.fs.common.core.domain.AjaxResult;
import com.fs.common.core.domain.model.LoginUser;
import com.fs.common.core.page.PageDomain;
import com.fs.common.core.page.TableDataInfo;
import com.fs.common.core.page.TableSupport;
import com.fs.common.enums.BusinessType;
import com.fs.common.utils.ParseUtils;
import com.fs.common.utils.ServletUtils;
import com.fs.common.utils.StringUtils;
import com.fs.company.domain.CompanyUser;
import com.fs.framework.security.SecurityUtils;
import com.fs.his.utils.PhoneUtil;
import com.fs.hisStore.dto.StoreOrderProductDTO;
import com.fs.hisStore.service.IMergedOrderService;
import com.fs.hisStore.vo.FsStoreOrderItemExportVO;
import com.fs.live.param.MergedOrderQueryParam;
import com.fs.live.vo.MergedOrderVO;
import com.fs.live.vo.MergedOrderExportVO;
import com.fs.common.utils.poi.ExcelUtil;
import org.springframework.beans.BeanUtils;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 合并订单Controller
 *
 * @author fs
 * @date 2025-01-XX
 */
@Api("合并订单管理")
@RestController
@RequestMapping("/order")
public class OrderController extends BaseController
{
    @Autowired
    private IMergedOrderService mergedOrderService;
    // 设置最大导出数量限制为20000条
    private static final int maxExportCount = 50000;



    /**
     * 查询合并订单列表
     */
    @ApiOperation("查询合并订单列表")
    @GetMapping("/list")
    public TableDataInfo list(MergedOrderQueryParam param)
    {
        // 从请求参数中获取分页信息
        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();
        Integer pageSize = pageDomain.getPageSize();

        // 设置分页参数到 param
        if (pageNum == null || pageNum < 1) {
            pageNum = 1;
            param.setPageNum(1);
        } else {
            param.setPageNum(pageNum);
        }
        if (pageSize == null || pageSize < 1) {
            pageSize = 10;
            param.setPageSize(10);
        } else {
            param.setPageSize(pageSize);
        }

        // 在外面计算 offset，然后放在请求参数中
        Integer offset = (pageNum - 1) * pageSize;
        param.setOffset(offset);

        // 设置公司ID和用户ID
        CompanyUser user = SecurityUtils.getLoginUser().getUser();
        param.setCompanyId(user.getCompanyId());
        if (user.getUserType().equals("01")){
            param.setUserId(user.getUserId());
        }

        // 如果 OrderTypeFilter 为空，只查询销售和直播订单，不查询商城订单
        // 通过设置一个特殊值来实现，或者修改查询逻辑
        // 这里我们通过修改查询逻辑来实现：如果 orderTypeFilter 为 null，在 SQL 中排除商城订单

        // 先查询总数（不分页）
        long total = mergedOrderService.countMergedOrderList(param);

        // 查询分页数据
        List<MergedOrderVO> list = mergedOrderService.selectMergedOrderList(param);
        for (MergedOrderVO vo : list) {
            vo.setUserPhone(ParseUtils.parsePhone(vo.getUserPhone()));
            vo.setPhone(ParseUtils.parsePhone(vo.getPhone()));
            vo.setSalesPhone(ParseUtils.parsePhone(vo.getSalesPhone()));
            vo.setUserAddress(ParseUtils.parseAddress(vo.getUserAddress()));
            vo.setCost(BigDecimal.ZERO);
        }

        TableDataInfo dataTable = new TableDataInfo();
        dataTable.setCode(HttpStatus.SUCCESS);
        dataTable.setMsg("查询成功");
        dataTable.setRows(list);
        dataTable.setTotal(total);
        return dataTable;
    }

    /**
     * 导出合并订单列表
     */
    @PreAuthorize("@ss.hasPermi('live:order:export')")
    @ApiOperation("导出合并订单列表")
    @Log(title = "合并订单", businessType = BusinessType.EXPORT)
    @GetMapping("/export")
    public AjaxResult export(MergedOrderQueryParam param)
    {
        if(param.getOrderTypeFilter() == null || param.getOrderTypeFilter().equals("2")){
            return AjaxResult.error("请选择导出订单类型！");
        }
        // 先查询数据，限制查询20001条，用于判断是否超过限制
        CompanyUser user = SecurityUtils.getLoginUser().getUser();
        param.setCompanyId(user.getCompanyId());
        PageHelper.startPage(1, maxExportCount + 1);
        List<MergedOrderVO> list = mergedOrderService.selectMergedOrderList(param);
        list = list.stream().filter(item -> StringUtils.isNotEmpty(item.getBankTransactionId())).collect(Collectors.toList());

        // 如果查询结果超过20000条，返回错误提示
        if (list != null && list.size() > maxExportCount) {
            return AjaxResult.error("导出数据量超过限制，最多只能导出" + maxExportCount + "条数据，请缩小查询范围后重试");
        }

        for (MergedOrderVO vo : list) {
            if (!StringUtils.isEmpty(vo.getItemJson())) {
                try {
                    StoreOrderProductDTO orderProductDTO = JSONObject.parseObject(vo.getItemJson(), StoreOrderProductDTO.class);
                    BeanUtil.copyProperties(orderProductDTO, vo);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                }
            }
        }

        // 转换为导出VO
        List<MergedOrderExportVO> exportList = convertToExportVO(list, false);

        // 如果数据量在限制范围内，正常导出
        ExcelUtil<MergedOrderExportVO> util = new ExcelUtil<>(MergedOrderExportVO.class);
        return util.exportExcel(exportList, "合并订单数据");
    }

    /**
     * 导出合并订单(明文)
     */
    @PreAuthorize("@ss.hasPermi('live:order:exportAll')")
    @ApiOperation("导出合并订单(明文)")
    @Log(title = "合并订单(明文)", businessType = BusinessType.EXPORT)
    @GetMapping("/exportDetails")
    public AjaxResult exportDetails(MergedOrderQueryParam param)
    {
        if(param.getOrderTypeFilter() == null || param.getOrderTypeFilter().equals("2")){
            return AjaxResult.error("请选择导出订单类型！");
        }
        // 先查询数据，限制查询20001条，用于判断是否超过限制
        CompanyUser user = SecurityUtils.getLoginUser().getUser();
        param.setCompanyId(user.getCompanyId());
        PageHelper.startPage(1, maxExportCount + 1);
        List<MergedOrderVO> list = mergedOrderService.selectMergedOrderList(param);
        list = list.stream().filter(item -> StringUtils.isNotEmpty(item.getBankTransactionId())).collect(Collectors.toList());

        // 如果查询结果超过20000条，返回错误提示
        if (list != null && list.size() > maxExportCount) {
            return AjaxResult.error("导出数据量超过限制，最多只能导出" + maxExportCount + "条数据，请缩小查询范围后重试");
        }

        for (MergedOrderVO vo : list) {
            if (!StringUtils.isEmpty(vo.getItemJson())) {
                try {
                    StoreOrderProductDTO orderProductDTO = JSONObject.parseObject(vo.getItemJson(), StoreOrderProductDTO.class);
                    BeanUtil.copyProperties(orderProductDTO, vo);
                } catch (Exception e) {
                }
            }
        }
        // 转换为导出VO（明文模式，不脱敏）
        List<MergedOrderExportVO> exportList = convertToExportVO(list, true);

        ExcelUtil<MergedOrderExportVO> util = new ExcelUtil<>(MergedOrderExportVO.class);
        return util.exportExcel(exportList, "合并订单(明文)");
    }

    /**
     * 导出合并订单明细
     */
    @ApiOperation("导出合并订单明细")
    @Log(title = "合并订单明细", businessType = BusinessType.EXPORT)
    @GetMapping("/exportItems")
    public AjaxResult exportItems(MergedOrderQueryParam param)
    {
        // 先查询数据，限制查询20001条，用于判断是否超过限制
        PageHelper.startPage(1, maxExportCount + 1);
        List<MergedOrderVO> list = mergedOrderService.selectMergedOrderList(param);

        // 如果查询结果超过20000条，返回错误提示
        if (list != null && list.size() > maxExportCount) {
            return AjaxResult.error("导出数据量超过限制，最多只能导出" + maxExportCount + "条数据，请缩小查询范围后重试");
        }

        ExcelUtil<MergedOrderVO> util = new ExcelUtil<>(MergedOrderVO.class);
        return util.exportExcel(list, "合并订单明细");
    }



    /**
     * 导出合并订单明细(明文)
     */
    @ApiOperation("导出合并订单明细(明文)")
    @Log(title = "合并订单明细(明文)", businessType = BusinessType.EXPORT)
    @GetMapping("/exportItemsDetails")
    public AjaxResult exportItemsDetails(MergedOrderQueryParam param)
    {
        // 先查询数据，限制查询20001条，用于判断是否超过限制
        PageHelper.startPage(1, maxExportCount + 1);
        List<MergedOrderVO> list = mergedOrderService.selectMergedOrderList(param);

        // 如果查询结果超过20000条，返回错误提示
        if (list != null && list.size() > maxExportCount) {
            return AjaxResult.error("导出数据量超过限制，最多只能导出" + maxExportCount + "条数据，请缩小查询范围后重试");
        }

        ExcelUtil<MergedOrderVO> util = new ExcelUtil<>(MergedOrderVO.class);
        return util.exportExcel(list, "合并订单明细(明文)");
    }

    /**
     * 导出合并订单发货单
     */
    @ApiOperation("导出合并订单发货单")
    @Log(title = "合并订单发货单", businessType = BusinessType.EXPORT)
    @GetMapping("/exportShipping")
    public AjaxResult exportShipping(MergedOrderQueryParam param)
    {
        // 先查询数据，限制查询20001条，用于判断是否超过限制
        PageHelper.startPage(1, maxExportCount + 1);
        List<MergedOrderVO> list = mergedOrderService.selectMergedOrderList(param);
        // 如果查询结果超过20000条，返回错误提示
        if (list != null && list.size() > maxExportCount) {
            return AjaxResult.error("导出数据量超过限制，最多只能导出" + maxExportCount + "条数据，请缩小查询范围后重试");
        }
        ExcelUtil<MergedOrderVO> util = new ExcelUtil<>(MergedOrderVO.class);
        return util.exportExcel(list, "合并订单发货单");
    }

    /**
     * 将 MergedOrderVO 转换为 MergedOrderExportVO
     * @param list 原始数据列表
     * @param isPlainText 是否为明文模式（true：不脱敏，false：脱敏）
     * @return 导出VO列表
     */
    private List<MergedOrderExportVO> convertToExportVO(List<MergedOrderVO> list, boolean isPlainText)
    {
        if (list == null || list.isEmpty()) {
            return new ArrayList<>();
        }

        return list.stream().map(vo -> {
            MergedOrderExportVO exportVO = new MergedOrderExportVO();

            // 订单基本信息（参考 FsStoreOrderItemExportVO 的顺序）
            exportVO.setOrderTypeName(vo.getOrderTypeName());
            exportVO.setOrderCode(vo.getOrderCode());
            exportVO.setStatus(vo.getStatus() != null ? String.valueOf(vo.getStatus()) : null);
            exportVO.setUserId(vo.getUserId());

            // 产品信息
            exportVO.setProductName(StringUtils.isEmpty(vo.getProductName()) ? "产品被删除" : vo.getProductName());
            exportVO.setBarCode(vo.getBarCode());
            exportVO.setProductSpec(StringUtils.isEmpty(vo.getProductSpec()) ? "默认" : vo.getProductSpec());
            exportVO.setTotalNum(vo.getTotalNum());
            exportVO.setPrice(vo.getTotalPrice()); // 产品价格使用订单总价
            exportVO.setCost(BigDecimal.ZERO);
            exportVO.setFPrice(BigDecimal.ZERO); // 结算价，合并订单暂无此字段
            exportVO.setPayPostage(vo.getPayDelivery());
            exportVO.setCateName(StringUtils.isEmpty(vo.getCateName()) ? "产品被删除" : vo.getCateName());

            // 收货信息
            exportVO.setRealName(vo.getRealName());
            exportVO.setUserPhone(ParseUtils.parsePhone(vo.getUserPhone()));
            exportVO.setUserAddress(ParseUtils.parseAddress(vo.getUserAddress()));
            // 时间信息
            exportVO.setCreateTime(vo.getCreateTime());
            exportVO.setPayTime(vo.getPayTime());

            // 物流信息
            exportVO.setDeliverySn(vo.getDeliveryCode()); // 快递公司编号，合并订单暂无此字段
            exportVO.setDeliveryName(vo.getDeliveryName()); // 快递公司，合并订单暂无此字段
            exportVO.setDeliveryId(vo.getDeliveryId());

            // 公司和销售信息
            exportVO.setCompanyName(vo.getCompanyName());
            exportVO.setCompanyUserNickName(vo.getCompanyUserNickName());
            exportVO.setHfshh(vo.getHfshh());

            // 套餐信息
            exportVO.setPackageName(null); // 套餐名称，合并订单暂无此字段
            exportVO.setGroupBarCode(null); // 组合码，合并订单暂无此字段

            // 凭证信息
            exportVO.setIsUpload(null); // 是否上传凭证，合并订单暂无此字段
            exportVO.setUploadTime(null); // 上传时间，合并订单暂无此字段

            // 档期信息
            exportVO.setScheduleName(null); // 归属档期，合并订单暂无此字段

            // 银行交易流水号
            exportVO.setBankTransactionId(vo.getBankTransactionId());

            // 金额信息
            exportVO.setTotalPrice(vo.getTotalPrice());
            exportVO.setPayPrice(vo.getPayPrice());
            exportVO.setPayMoney(vo.getPayMoney());
            exportVO.setPayPostage(vo.getPayDelivery()); // 额外运费，合并订单暂无此字段
            exportVO.setPayDelivery(vo.getPayDelivery());

            return exportVO;
        }).collect(Collectors.toList());
    }
}
