package com.ruoyi.order.controller;


import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.account.api.feignClient.AppUserClient;
import com.ruoyi.account.api.model.TAppUser;
import com.ruoyi.chargingPile.api.dto.GetSiteListDTO;
import com.ruoyi.chargingPile.api.feignClient.PartnerClient;
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.page.PageInfo;
import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.log.enums.OperatorType;
import com.ruoyi.common.security.annotation.Logical;
import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.order.api.model.*;
import com.ruoyi.order.api.query.TOrderAppealQuery;
import com.ruoyi.order.api.vo.TOrderAppealVO;
import com.ruoyi.order.dto.ManageFeedbackDto;
import com.ruoyi.order.dto.ManageOrderAppealQuery;
import com.ruoyi.order.service.*;
import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.api.feignClient.SysUserClient;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.*;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author xiaochen
 * @since 2024-08-07
 */
@RestController
@RequestMapping("/t-order-appeal")
public class TOrderAppealController {

    private final TOrderAppealService orderAppealService;
    private final TokenService tokenService;
    @Resource
    private AppUserClient appUserClient;
    @Resource
    private TChargingOrderService chargingOrderService;
    @Resource
    private TShoppingOrderService shoppingOrderService;
    @Resource
    private TExchangeOrderService exchangeOrderService;

    @Resource
    private TVipOrderService vipOrderService;
    
    @Resource
    private SysUserClient sysUserClient;
    
    @Resource
    private PartnerClient partnerClient;

    @Autowired
    public TOrderAppealController(TOrderAppealService orderAppealService, TokenService tokenService) {
        this.orderAppealService = orderAppealService;
        this.tokenService = tokenService;
    }
    @Resource
    private SiteClient siteClient;
    
    
    @RequiresPermissions(value = {"/appealOrder"}, logical = Logical.OR)
    @ApiOperation(tags = {"后台-订单管理-订单申诉"},value = "列表")
    @PostMapping(value = "/manage/pageList")
    public R<Page<TOrderAppeal>> managePageList(@RequestBody ManageOrderAppealQuery manageOrderAppealQuery) {
        Integer pageCurr = manageOrderAppealQuery.getPageCurr();
        Integer pageSize = manageOrderAppealQuery.getPageSize();
        boolean hasSiteFilter = manageOrderAppealQuery.getSiteId() != null
                || manageOrderAppealQuery.getPartnerId() != null
                || manageOrderAppealQuery.getSiteType() != null;
        Page<TOrderAppeal> page = orderAppealService.lambdaQuery().eq(manageOrderAppealQuery.getStatus() != null, TOrderAppeal::getStatus, manageOrderAppealQuery.getStatus())
                .like(manageOrderAppealQuery.getCode() != null, TOrderAppeal::getCode, manageOrderAppealQuery.getCode())
                .like(manageOrderAppealQuery.getPhone() != null, TOrderAppeal::getPhone, manageOrderAppealQuery.getPhone())
                .eq(manageOrderAppealQuery.getOrderType() != null, TOrderAppeal::getOrderType, manageOrderAppealQuery.getOrderType())
                .in(TOrderAppeal::getOrderType, 1, 2)
                .orderByDesc(TOrderAppeal::getCreateTime)
                .page(Page.of(1, 99999999));
        SysUser sysUser = sysUserClient.getSysUser(tokenService.getLoginUser().getUserid()).getData();
        Integer roleType = sysUser.getRoleType();
        boolean partnerUser = Objects.equals(roleType, 2);
        Map<Integer, GetSiteListDTO> visibleSiteMap = partnerUser || hasSiteFilter
                ? getVisibleSiteMap(sysUser)
                : Collections.emptyMap();
        Set<Integer> partnerSiteIds = partnerUser ? visibleSiteMap.keySet() : Collections.emptySet();
        List<TOrderAppeal> res = new ArrayList<>();
        for (TOrderAppeal record : page.getRecords()) {
            record.setUid(record.getId() + "");
            if (!Objects.equals(record.getOrderType(), 1)) {
                if (!partnerUser && !hasSiteFilter) {
                    res.add(record);
                }
                continue;
            }

            TChargingOrder chargingOrder = chargingOrderService.getById(record.getOrderId());
            if (chargingOrder == null) {
                record.setAuthInfo(false);
                record.setAuthHandle(false);
                continue;
            }

            Integer siteId = chargingOrder.getSiteId();
            if (partnerUser && !partnerSiteIds.contains(siteId)) {
                continue;
            }
            if (hasSiteFilter && !matchSiteFilter(siteId, visibleSiteMap, manageOrderAppealQuery)) {
                continue;
            }
            if (partnerUser) {
                List<Boolean> data = partnerClient.managePageListMenu(sysUser.getObjectId(), siteId).getData();
                record.setAuthInfo(getMenuFlag(data, 0));
                record.setAuthHandle(getMenuFlag(data, 1));
            }
            res.add(record);
        }
        List<TOrderAppeal> res1 = testing4(res.size(), pageCurr, pageSize, res);
        page.setCurrent(pageCurr);
        page.setSize(pageSize);
        page.setTotal(res.size());
        page.setRecords(res1);
        return R.ok(page);
    }

    Map<Integer, GetSiteListDTO> getVisibleSiteMap(SysUser sysUser) {
        if (sysUser == null || sysUser.getUserId() == null) {
            return Collections.emptyMap();
        }
        R<List<GetSiteListDTO>> result = siteClient.getSiteListByUserId(sysUser.getUserId());
        Map<Integer, GetSiteListDTO> siteMap = new HashMap<>();
        if (result == null || result.getData() == null) {
            return siteMap;
        }
        List<GetSiteListDTO> data = result.getData();
        if (data != null) {
            for (GetSiteListDTO datum : data) {
                if (datum != null && datum.getId() != null && datum.getId() > 0) {
                    siteMap.put(datum.getId(), datum);
                }
            }
        }
        return siteMap;
    }

    private boolean matchSiteFilter(Integer siteId, Map<Integer, GetSiteListDTO> siteMap, ManageOrderAppealQuery query) {
        if (query.getSiteId() != null && !query.getSiteId().equals(siteId)) {
            return false;
        }
        GetSiteListDTO site = siteMap.get(siteId);
        if (query.getPartnerId() != null && (site == null || !query.getPartnerId().equals(site.getPartnerId()))) {
            return false;
        }
        return query.getSiteType() == null || (site != null && query.getSiteType().equals(site.getSiteType()));
    }

    private boolean getMenuFlag(List<Boolean> menuFlags, int index) {
        return menuFlags != null && menuFlags.size() > index && Boolean.TRUE.equals(menuFlags.get(index));
    }
    public static List<TOrderAppeal> testing4(long total, long current, long size, List<TOrderAppeal> str){
        List<TOrderAppeal> result = new ArrayList<>();
        //获取初始化分页结构
        com.ruoyi.order.util.Page<TOrderAppeal> page = new com.ruoyi.order.util.Page().getPage(total, size, current - 1);
        //获取集合下标初始值
        long startIndex = page.getStartIndex();
        //获取集合下标结束值
        long endInddex = 0;
        if(startIndex + page.getCurrent() >= total || size > total){
            endInddex = total;
        }else {
            endInddex = Math.min(startIndex + page.getSize(), total);
        }
        //如果输入的开始查询下标大于集合大小，则查询为空值
        if(startIndex > total){
            result = Collections.emptyList();
        }else{
            result = str.subList((int)startIndex,(int)endInddex);
        }
        return result;
    }
    
    @RequiresPermissions(value = {"/appealOrder/del"}, logical = Logical.OR)
    @ApiOperation(tags = {"后台-订单管理-订单申诉"},value = "删除")
    @DeleteMapping (value = "/manage/delete")
    public R<Page<TOrderAppeal>> delete(String ids) {
        orderAppealService.removeBatchByIds(Arrays.asList(ids.split(",")));
        return R.ok();
    }
    
    
    
    @RequiresPermissions(value = {"/appealOrder/select", "/appealOrder/handle"}, logical = Logical.OR)
    @ApiOperation(tags = {"后台-订单管理-订单申诉"},value = "后台-订单管理-订单申诉")
    @PostMapping(value = "/manage/feedback")
    public R manageFeedback(@RequestBody ManageFeedbackDto manageFeedbackDto) {
        TOrderAppeal byId = orderAppealService.getById(manageFeedbackDto.getId());
        byId.setFeedback(manageFeedbackDto.getFeedback());
        byId.setStatus(2);
        orderAppealService.updateById(byId);
        return R.ok();
    }

    /**
     * 查询订单申诉列表
     */
    @ApiOperation(tags = {"小程序-订单申诉"},value = "查询订单申诉分页列表")
    @PostMapping(value = "/pageList")
    public AjaxResult<PageInfo<TOrderAppealVO>> pageList(@RequestBody TOrderAppealQuery query) {
        Long userId = tokenService.getLoginUserApplet().getUserId();
        query.setAppUserId(userId);
        return AjaxResult.ok(orderAppealService.pageList(query));
    }

    /**
     * 查询订单申诉详情
     */
    @GetMapping(value = "/getDetailById")
    @ApiOperation(tags = {"小程序-订单申诉"},value = "查询订单申诉详情")
    public AjaxResult<TOrderAppealVO> getDetailById(String id) {
        TOrderAppeal orderAppeal = orderAppealService.getById(id);
        Long userId = tokenService.getLoginUserApplet().getUserId();
        if(!orderAppeal.getAppUserId().equals(userId)){
            return AjaxResult.error("权限不足");
        }
        return AjaxResult.ok(orderAppealService.getDetailById(id));
    }
    
    
    
    @Log(title = "【我的】申诉订单", businessType = BusinessType.INSERT,operatorType = OperatorType.MOBILE)
    @ResponseBody
    @PostMapping(value = "/addOrderAppeal")
    @ApiOperation(value = "申诉订单", tags = {"小程序-充电记录（个人中心）"})
    public AjaxResult addOrderAppeal(@RequestBody TOrderAppeal orderAppeal){
        Long appUserId = tokenService.getLoginUserApplet().getUserId();
        TAppUser data = appUserClient.getUserById(appUserId).getData();
        orderAppeal.setAppUserId(appUserId);
        orderAppeal.setStatus(1);
        orderAppeal.setPhone(data.getPhone());

        if (orderAppeal.getOrderType()==1){
            TChargingOrder byId = chargingOrderService.getById(orderAppeal.getOrderId());
            orderAppeal.setCode(byId.getCode());
        }else if(orderAppeal.getOrderType()==2){
            TShoppingOrder byId = shoppingOrderService.getById(orderAppeal.getOrderId());
            orderAppeal.setCode(byId.getCode());
        }else if(orderAppeal.getOrderType()==3){
            TExchangeOrder byId = exchangeOrderService.getById(orderAppeal.getOrderId());
            orderAppeal.setCode(byId.getCode());
        }else if(orderAppeal.getOrderType()==4){
            TVipOrder byId = vipOrderService.getById(orderAppeal.getOrderId());
            orderAppeal.setCode(byId.getCode());
        }
        orderAppealService.save(orderAppeal);
        return AjaxResult.success();
    }

    /**
     * 查询订单申诉详情
     */
    @GetMapping(value = "/getDetailByOrderId")
    @ApiOperation(tags = {"H5-通过订单id查询订单申诉"},value = "通过订单id查询订单申诉")
    public R<TOrderAppealVO> getDetailByOrderId(String orderId) {
        TOrderAppeal orderAppeal = orderAppealService.getOne(Wrappers.lambdaQuery(TOrderAppeal.class)
                .eq(TOrderAppeal::getOrderId,orderId)
                .orderByDesc(TOrderAppeal::getCreateTime)
                .last("LIMIT 1"));
        if(Objects.isNull(orderAppeal)){
            return R.ok();
        }
        return R.ok(orderAppealService.getDetailById(String.valueOf(orderAppeal.getId())));
    }
}