package com.bawei.mall.car.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.bawei.common.core.utils.JwtUtils;
import com.bawei.common.security.utils.SecurityUtils;
import com.bawei.mall.car.domain.CarBySku;
import com.bawei.mall.car.domain.MallProductSkuCarInfo;
import com.bawei.mall.car.domain.ProductPrices;
import com.bawei.mall.car.domain.ProductSkuInfo;
import com.bawei.mall.car.mapper.CarMapper;
import com.bawei.mall.car.service.CarService;
import com.bawei.mall.product.domain.MallProductSkuInfo;
import com.fasterxml.jackson.core.type.TypeReference;
import io.jsonwebtoken.Claims;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

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


/**
 * 购物车服务实现类
 */
@Service
@Log4j2
public class CarServiceImpl implements CarService {
    /**
     * 购物车Mapper依赖注入
     */
    @Autowired
    private CarMapper carMapper;
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    /**
     * 添加商品到购物车
     *
     * @param skuId 商品ID
     * @param status 状态（0：添加，非0：删除）
     */
    @Override
    public void addCar(Integer skuId, Integer status) {
        if (skuId == null || skuId==0||skuId<0) {
            throw new RuntimeException("商品ID不能为空");
        }
        if (status==null||status<0){
            throw new RuntimeException("状态不能为空");
        }

        String token = queryUserId();
        // 获取用户ID
        Long userId = Long.valueOf(JwtUtils.getUserId(token));
        //查询sku
        MallProductSkuInfo mallProductSkuInfo=carMapper.querySku(skuId);
        if (mallProductSkuInfo==null){
            throw new RuntimeException("商品不存在");
        }
        // 查询购物车
        String carId = carMapper.queryCar(userId);
        if (carId == null) {
            carId= UUID.randomUUID().toString().replaceAll("-", "");
            // 新增购物车
            carMapper.insertCar(userId, carId);
            // 将商品信息和购物车ID进行关联
            carMapper.addCarBySkuId(skuId, carId, userId);
        }
        //查询购物车
        CarBySku carBySku = carMapper.showCarBySkuId(skuId, carId);
        if (carBySku==null){
            carMapper.addCarBySkuId(skuId,carId,userId);
        }else {
            // 根据状态进行操作
            if (status == 0) {
                toAddCar(skuId, carId);
            } else {
                toDelCar(skuId, carId);
            }
        }


    }

    /**
     * 减少商品数量（从购物车中删除商品）
     *
     * @param skuId 商品ID
     * @param carId 购物车ID
     */
    private void toDelCar(Integer skuId, String carId) {
        // 查询购物车数量
        CarBySku carBySku = carMapper.showCarBySkuId(skuId, carId);
        // 判断购物车数量
        if (carBySku.getNumber() <= 1) {
            throw new RuntimeException("购物车数量为1,不能再减了");
        } else {
            // 更新购物车商品数量
            carMapper.updCarBySkuId(skuId, carId, carBySku.getNumber() - 1);
        }
    }

    /**
     * 增加商品数量（向购物车中添加商品）
     *
     * @param skuId 商品ID
     * @param carId 购物车ID
     */
    private void toAddCar(Integer skuId, String carId) {
        // 查询购物车商品信息
        CarBySku carBySku = carMapper.showCarBySkuId(skuId, carId);
        if (carBySku==null){
            throw new RuntimeException("购物车商品不存在");
        }
        // 更新购物车商品数量
        carMapper.updCarBySkuId(skuId, carId, carBySku.getNumber() + 1);
    }

    /**
     * 获取当前登录用户ID
     *
     * @return 用户ID
     */
    private String queryUserId() {
        // 获取用户ID
        String token = SecurityUtils.getToken();
        JwtUtils.parseToken(token);
        return token;
    }


    /**
     * 更新购物车商品数量
     *
     * @param skuId 商品ID
     * @param num 商品数量
     */
    @Override
    public void updCar(Integer skuId, Integer num) {
        String token = queryUserId();
        // 获取用户ID
        Long userId = Long.valueOf(JwtUtils.getUserId(token));

        // 查询购物车
        String carId = carMapper.queryCar(userId);
        if (carId == null) {
            throw new RuntimeException("购物车错误");
        }
        // 更新购物车商品数量
        carMapper.updCarBySkuId(skuId, carId, num);
    }

    /**
     * 删除整个购物车
     */
    @Override
    public void delCar() {
        String token = queryUserId();
        // 获取用户ID
        Long userId = Long.valueOf(JwtUtils.getUserId(token));
        // 查询购物车
        String carId =  carMapper.queryCar(userId);
        if (carId == null) {
            throw new RuntimeException("购物车不存在");
        }
        // 删除购物车关联记录
        carMapper.delCarBySkuId(carId);
        // 删除购物车记录
        carMapper.delCar(userId);
    }

    /**
     * 根据商品ID列表批量删除购物车商品
     *
     * @param skuIds 商品ID列表
     */
    @Override
    public void delById(String skuIds) {
        // 检查商品ID列表是否为空
        if (skuIds.isEmpty()) {
            throw new RuntimeException("skuIds不能为空");
        }

        String token = queryUserId();
        // 获取用户ID
        Long userId = Long.valueOf(JwtUtils.getUserId(token));
        String carId = carMapper.queryCar(userId);
        String[] split = skuIds.split(",");
        // 遍历商品ID列表并删除购物车关联记录
        for (String skuId : split) {
            carMapper.delCarBySkuIdInfo(Integer.valueOf(skuId), carId);
        }
    }

    @Override
    public MallProductSkuCarInfo calculate() {
        MallProductSkuCarInfo mallProductSkuCarInfo = new MallProductSkuCarInfo();
        List<ProductSkuInfo> productSkuInfos = new ArrayList<>();
        ProductPrices productPrices = new ProductPrices();
        String token = queryUserId();
        Long userId = Long.valueOf(JwtUtils.getUserId(token));
        String carId = carMapper.queryCar(userId);
        List<Integer> skuIds = carMapper.querySkuId(carId);
        if (skuIds.size()==0){
            throw new RuntimeException("购物车为空");
        }
        //查询reids里面的数据,如果redis里面没有就去数据库查
        if (redisTemplate.hasKey("car")){
            List<String> car = redisTemplate.opsForList().range("car", 0, -1);
                productSkuInfos = car.stream()
                    .map(carProductInfo -> JSON.parseObject(carProductInfo,ProductSkuInfo.class))
                    .collect(Collectors.toList());
            mallProductSkuCarInfo.setProductSkuInfo(productSkuInfos);
        }else {
                productSkuInfos =  carMapper.querySkus(skuIds,carId);
                redisTemplate.opsForList().rightPushAll("car",JSON.toJSONString(productSkuInfos));
        }

        if (productSkuInfos.size()==0){
            throw new RuntimeException("购物车商品不存在");
        }
        mallProductSkuCarInfo.setProductSkuInfo(productSkuInfos);
        productPrices.setPrice(new BigDecimal(0));
        productPrices.setSpecialOffer(new BigDecimal(0));
        productPrices.setAfterDiscounts(new BigDecimal(0));
        BigDecimal bigDecimal = new BigDecimal(0);
        for (ProductSkuInfo productSkuInfo : productSkuInfos) {
            BigDecimal skuPrice = productSkuInfo.getSkuPrice();
            BigDecimal number = BigDecimal.valueOf(productSkuInfo.getNumber());

            // 使用bigDecimal的add()方法，并将结果保存回bigDecimal
            bigDecimal = bigDecimal.add(skuPrice.multiply(number));
        }
        productPrices.setPrice(bigDecimal);

        //TODO 假设有个VIP
        Claims claims = JwtUtils.parseToken(token);
        log.info("claims:{}",claims);
        String VIP="admin";
        if (VIP.equals(JwtUtils.getUserName(claims))){
            getVIP(productPrices);
        }
        mallProductSkuCarInfo.setProductPrices(productPrices);
        return mallProductSkuCarInfo;
    }

    private void getVIP(ProductPrices productPrices) {
        // 计算VIP折扣后的价格
        BigDecimal vipDiscountRate = new BigDecimal("0.9");
        BigDecimal afterDiscounts = productPrices.getPrice().multiply(vipDiscountRate);
        productPrices.setAfterDiscounts(afterDiscounts);

    // 计算VIP优惠与原价的差距
        BigDecimal specialOffer = productPrices.getPrice().subtract(afterDiscounts);
        productPrices.setSpecialOffer(specialOffer);
    }

}





































