package com.xiaopeng.order.controller;


import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xiaopeng.api.dto.account.UcUserInfo;
import com.xiaopeng.api.dto.vehicleConvoy.ServiceVehicleListDto;
import com.xiaopeng.api.feignClient.account.UserResourcesClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.map.XpGeoFencingPolygon;
import com.xiaopeng.api.model.order.XpOrder;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.api.vo.automaticPilot.AppUserPosition;
import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
import com.xiaopeng.api.vo.vehicleConvoy.VehicleDoorStatusVo;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.utils.StringUtils;
import com.xiaopeng.order.dto.UserOrderListDto;
import com.xiaopeng.order.mangodb.model.OrderTrajectory;
import com.xiaopeng.order.service.IXpOrderService;
import com.xiaopeng.order.vo.*;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 提供三方客服系统接口
 */
@RestController
@RequestMapping("/logan/rt/customerService")
public class CustomerServiceController {

    @Resource
    private XpVehicleClient xpVehicleClient;

    @Resource
    private IXpOrderService xpOrderService;

    @Resource
    private UserResourcesClient userResourcesClient;

    @Resource
    private MongoTemplate mongoTemplate;


    /**
     * 1. 判断 VIN 是否为 robotaxi 车辆
     * @param vin
     * @return
     */
    @GetMapping("/isRobotaxi/{vin}")
    @ApiOperation(value = "判断 VIN 是否为 robotaxi 车辆", notes = "客服系统对接")
    @ApiImplicitParam(name = "vin", value = "VIN码", required = true, dataType = "string", paramType = "path")
    public R<Boolean> isRobotaxi(@PathVariable String vin){
        XpVehicle xpVehicle = xpVehicleClient.findByVehicleVin(vin).getData();
        if(null != xpVehicle){
            return R.ok(true);
        }
        return R.ok(false);
    }


    /**
     * 2. 根据 VIN 查询在途/最近订单客户手机号
     * @param vin
     * @return
     */
    @GetMapping("/getServiceOrder/{vin}")
    @ApiOperation(value = "根据 VIN 查询在途/最近订单客户手机号", notes = "客服系统对接")
    @ApiImplicitParam(name = "vin", value = "VIN码", required = true, dataType = "string", paramType = "path")
    public R<ServiceOrderVo> getServiceOrder(@PathVariable String vin){
        XpVehicle xpVehicle = xpVehicleClient.findByVehicleVin(vin).getData();
        if(null == xpVehicle){
            return R.ok();
        }
        XpOrder one = xpOrderService.getOne(new QueryWrapper<XpOrder>().eq("vehicle_id", xpVehicle.getId())
                .eq("is_deleted", 0).last(" order by create_time desc limit 1"));
        if(null == one){
            return R.ok();
        }
        ServiceOrderVo vo = new ServiceOrderVo();
        vo.setOrderId(one.getId());
        UcUserInfo ucUserInfo = userResourcesClient.getBaseUserByUid(one.getAppUserId().toString());
        vo.setCustomerPhone(null != ucUserInfo ? ucUserInfo.getMobile() : null);
        vo.setHasActiveOrder(!Arrays.asList(0, 8, 9, 10).contains(one.getStatus()));
        return R.ok(vo);
    }


    /**
     * 3. 获取当前在运营车辆列表
     * @param dto
     * @return
     */
    @PostMapping("/getServiceVehicleList")
    @ApiOperation(value = "获取当前在运营车辆列表", notes = "客服系统对接")
    public R<List<ServiceVehicleListVo>> getServiceVehicleList(@RequestBody ServiceVehicleListDto dto){
        R<List<XpVehicle>> serviceVehicleList = xpVehicleClient.getServiceVehicleList(dto);
        if(serviceVehicleList.getCode() != 200){
            return R.fail(serviceVehicleList.getMsg());
        }
        List<ServiceVehicleListVo> collect = serviceVehicleList.getData().stream().map(xpVehicle -> {
            ServiceVehicleListVo vo = new ServiceVehicleListVo();
            vo.setVin(xpVehicle.getVehicleVin());
            vo.setPlateNumber(xpVehicle.getPlateNumber());
            return vo;
        }).collect(Collectors.toList());
        return R.ok(collect);
    }


    /**
     * 4. 根据 UID 查询用户是否有 RT 订单 & 订单列表
     * @param dto
     * @return
     */
    @PostMapping("/getUserOrderList")
    @ApiOperation(value = "根据 UID 查询用户是否有 RT 订单 & 订单列表", notes = "客服系统对接")
    public R<List<UserOrderListVo>> getUserOrderList(@RequestBody UserOrderListDto dto){
        List<UserOrderListVo> userOrderList = xpOrderService.getUserOrderList(dto);
        return R.ok(userOrderList);
    }


    /**
     * 5. 根据订单号查询订单详情
     * @param orderId
     * @return
     */
    @GetMapping("/getOrderDetail/{orderId}")
    @ApiOperation(value = "根据订单号查询订单详情", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<OrderInfoVo> getOrderDetail(@PathVariable Long orderId){
        return R.ok(xpOrderService.getOrderInfo(orderId));
    }


    /**
     * 7. 根据订单号查询实际行驶路径
     * @param orderId
     * @return
     */
    @GetMapping("/getOrderHistoryTrajectory/{orderId}")
    @ApiOperation(value = "根据订单号查询实际行驶路径", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<List<TrajectoryVo>> getOrderHistoryTrajectory(@PathVariable Long orderId){
        List<OrderTrajectory> orderTrajectoryList = mongoTemplate.find(Query.query(Criteria.where("orderId").is(orderId)), OrderTrajectory.class);
        List<TrajectoryVo> collect = orderTrajectoryList.stream().map(trajectory -> {
            String[] split = trajectory.getLocation().split(",");
            TrajectoryVo jsonObject = new TrajectoryVo();
            jsonObject.setLng(Double.parseDouble(split[0]));
            jsonObject.setLat(Double.parseDouble(split[1]));
            return jsonObject;
        }).collect(Collectors.toList());
        return R.ok(collect);
    }


    /**
     * 8. 查询乘客位置
     * @param orderId
     * @return
     */
    @GetMapping("/getAppUserLocation/{orderId}")
    @ApiOperation(value = "查询乘客位置", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<AppUserLocationVo> getAppUserLocation(@PathVariable Long orderId){
        XpOrder xpOrder = xpOrderService.getById(orderId);
        if(null == xpOrder){
            return R.ok();
        }
        AppUserLocationVo vo = new AppUserLocationVo();
        AppUserPosition userPosition = mongoTemplate.findOne(Query.query(Criteria.where("appUserId").is(xpOrder.getAppUserId())), AppUserPosition.class);
        if(null != userPosition){
            vo.setPassengerLng(userPosition.getPoint().getX());
            vo.setPassengerLat(userPosition.getPoint().getY());
            return R.ok(vo);
        }
        return R.ok();
    }


    /**
     * 9. 根据 订单查询安全带及座椅传感器状态
     * @param orderId
     * @return
     */
    @GetMapping("/getVehicleSeatStatus/{orderId}")
    @ApiOperation(value = "根据 订单查询安全带及座椅传感器状态", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<VehicleSeatStatusVo> getVehicleSeatStatus(@PathVariable Long orderId){
        XpOrder xpOrder = xpOrderService.getById(orderId);
        if(null == xpOrder){
            return R.ok();
        }



        return R.ok();
    }




    /**
     * 10. 根据 VIN 查询剩余电量及预估续航
     * @param vin
     * @return
     */
    @GetMapping("/getVehicleRange/{vin}")
    @ApiOperation(value = "根据 VIN 查询剩余电量及预估续航", notes = "客服系统对接")
    @ApiImplicitParam(name = "vin", value = "vin码", required = true, dataType = "string", paramType = "path")
    public R<VehicleRangeVo> getVehicleRange(@PathVariable String vin){
        VehiclePosition vehiclePositions = mongoTemplate.findOne(Query.query(Criteria.where("vin").is(vin)), VehiclePosition.class);
        if(null == vehiclePositions){
            return R.ok();
        }
        VehicleRangeVo vo = new VehicleRangeVo();
        vo.setBatteryLevel(vehiclePositions.getCurrentElectricity());
        vo.setEstimatedRange(Double.valueOf(vehiclePositions.getMileageRange()));
        return R.ok(vo);
    }


    /**
     * 11. 根据 订单查询四门三盖状态
     * @param orderId
     * @return
     */
    @GetMapping("/getVehicleDoorStatus/{orderId}")
    @ApiOperation(value = "根据 订单查询四门三盖状态", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<VehicleDoorStatusVo> getVehicleDoorStatus(@PathVariable Long orderId){
        VehicleDoorStatusVo data = xpVehicleClient.getVehicleDoorStatus(orderId).getData();
        return R.ok(data);
    }



    /**
     * 12. 根据 订单查询车辆位置及电子围栏信息
     * @param orderId
     * @return
     */
    @GetMapping("/getVehicleFenceInformation/{orderId}")
    @ApiOperation(value = "根据 订单查询车辆位置及电子围栏信息", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<VehicleFenceInformationVo> getVehicleFenceInformation(@PathVariable Long orderId){
        XpOrder xpOrder = xpOrderService.getById(orderId);
        if(null == xpOrder){
            return R.ok();
        }
        XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
        VehiclePosition vehiclePositions = mongoTemplate.findOne(Query.query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
        if(null == vehiclePositions){
            return R.ok();
        }
        VehicleFenceInformationVo vo = new VehicleFenceInformationVo();
        vo.setVehicleLng(vehiclePositions.getPoint().getX());
        vo.setVehicleLat(vehiclePositions.getPoint().getY());
        XpGeoFencingPolygon fencingPolygon = mongoTemplate.findOne(Query.query(Criteria.where("areaId").is(xpOrder.getXpElectronicFenceAreaId())), XpGeoFencingPolygon.class);
        List<FenceVo> collect = fencingPolygon.getPoints().getPoints().stream().map(point -> {
            FenceVo fenceVo = new FenceVo();
            fenceVo.setLng(point.getX());
            fenceVo.setLat(point.getY());
            return fenceVo;
        }).collect(Collectors.toList());
        vo.setGeofenceBoundary(collect);

        GeoJsonPoint point = new GeoJsonPoint(vehiclePositions.getPoint().getX(), vehiclePositions.getPoint().getY());
        List<XpGeoFencingPolygon> polygon = mongoTemplate.find(Query.query(Criteria.where("points").intersects(point)), XpGeoFencingPolygon.class);
        Set<String> collect1 = polygon.stream().map(XpGeoFencingPolygon::getAreaId).collect(Collectors.toSet());
        vo.setIsOutOfGeofence(collect1.contains(xpOrder.getXpElectronicFenceAreaId()));
        return R.ok(vo);
    }


    /**
     * 13. 根据订单号查询订单日志
     * @param orderId
     * @return
     */
    @GetMapping("/getOrderInfo/{orderId}")
    @ApiOperation(value = "根据订单号查询订单日志", notes = "客服系统对接")
    @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "Long", paramType = "path")
    public R<UserOrderInfoVo> getOrderInfo(@PathVariable Long orderId){
        return R.ok(new UserOrderInfoVo());
    }
}