package com.stylefeng.guns.modular.system.controller;


import com.alibaba.druid.support.json.JSONUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.stylefeng.guns.core.base.tips.ErrorTip;
import com.stylefeng.guns.core.common.constant.JwtConstants;
import com.stylefeng.guns.core.common.exception.BizExceptionEnum;
import com.stylefeng.guns.core.exception.GunsException;
import com.stylefeng.guns.core.shiro.ShiroKit;
import com.stylefeng.guns.core.util.DateUtil;
import com.stylefeng.guns.modular.system.dto.QuestionDto;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.service.ITDeviceService;
import com.stylefeng.guns.modular.system.service.ITUserDataService;
import com.stylefeng.guns.modular.system.service.ITUserDateDataService;
import com.stylefeng.guns.modular.system.service.IUserService;
import com.stylefeng.guns.modular.system.util.*;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.apache.poi.ss.formula.functions.T;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Controller
public class AppController {

    @Autowired
    private IUserService userService;
    @Autowired
    private RedisService redisService;

    @ResponseBody
    @PostMapping("/api/question")
    @ApiOperation(value = "填写问卷调查", tags = {"App接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R queryHomeData(HttpServletRequest request, @RequestBody QuestionDto questionDto) throws JsonProcessingException {
        Integer uid =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
        User user = userService.selectById(uid);
        ObjectMapper mapper = new ObjectMapper();
            // 将TUserData数组转换为JSON字符串
            String jsonInString = mapper.writeValueAsString(questionDto);

        user.setQuestion(jsonInString);
        userService.updateById(user);
        return R.ok("填写成功");
    }

    @Autowired
    private ITDeviceService deviceService;
    @ResponseBody
    @PostMapping("/api/checkeq")
    @ApiOperation(value = "判断当前用户是否绑定硬件", tags = {"App接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R checkeq(HttpServletRequest request){
        Integer uid =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));

        List<TDevice> bindId = deviceService.selectList(new EntityWrapper<TDevice>().eq("bindId", uid));
        if (bindId.isEmpty()){
            return R.fail("当前用户暂未绑定设备");
        }
        return R.ok(bindId.get(0));
    }


    @ResponseBody
    @PostMapping("/api/unbind")
    @ApiOperation(value = "解绑", tags = {"App接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R unbind(HttpServletRequest request){
        Integer uid =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));

        List<TDevice> bindId = deviceService.selectList(new EntityWrapper<TDevice>().eq("bindId", uid));

        for (TDevice tDevice : bindId) {
            deviceService.deleteById(tDevice.getId());
        }

        return R.ok();
    }

    @ResponseBody
    @PostMapping("/api/checkques")
    @ApiOperation(value = "判断当前用户信息", tags = {"App接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R<User> checkques(HttpServletRequest request){
        Integer uid =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));

        User user = userService.selectById(uid);

        return R.ok(user);
    }

    @ResponseBody
    @PostMapping("/api/bind")
    @ApiOperation(value = "绑定设备", tags = {"App接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R bind(HttpServletRequest request, @RequestBody TDevice device){
        Integer uid =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
        device.setBindId(uid);
        if (deviceService.selectList(new EntityWrapper<TDevice>().eq("mac", device.getMac())).isEmpty()) {
            device.setBindId(uid);
            device.setBindTime(new Date());
            deviceService.insert(device);
        }else {
            TDevice serNum = deviceService.selectOne(new EntityWrapper<TDevice>().eq("serNum", device.getSerNum()));
            serNum.setBindId(uid);
            serNum.setBindTime(new Date());
            deviceService.updateById(serNum);
        }
        return R.ok();
    }

    @PostMapping("/api/changePwd")
    @ApiOperation(value = "修改密码", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R changePwd(@RequestParam String oldPwd, @RequestParam String newPwd, @RequestParam String rePwd,HttpServletRequest request) {
        if (!newPwd.equals(rePwd)) {
//            throw new GunsException(BizExceptionEnum.TWO_PWD_NOT_MATCH);
            return R.fail("两次输入密码不一致");
        }
        Integer userId =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
        User user = userService.selectById(userId);
        String oldMd5 = ShiroKit.md5(oldPwd, user.getSalt());
        if (user.getPassword().equals(oldMd5)) {
            String newMd5 = ShiroKit.md5(newPwd, user.getSalt());
            user.setPassword(newMd5);
            user.updateById();
            return R.ok();
        } else {
//            throw new GunsException(BizExceptionEnum.OLD_PWD_NOT_RIGHT);
            return R.fail("原密码不正确");
        }
    }

    @PostMapping("/api/changeInfo")
    @ApiOperation(value = "修改个人信息", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R changeInfo(@RequestBody User user,HttpServletRequest request) {

       userService.updateById(user);
       return R.ok();

    }

    @PostMapping("/api/datalist")
    @ApiOperation(value = "检测记录", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R<PageInfo<TUserDateData>> datalist(HttpServletRequest request, Integer pageNum, Integer pageSize, Integer night, String date) {
        Integer userId =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));

        PageHelper.startPage(pageNum,pageSize);

        EntityWrapper<TUserDateData> tUserDateDataEntityWrapper = new EntityWrapper<>();

        tUserDateDataEntityWrapper.eq("userId",userId).last("ORDER BY date desc,night desc");
        if (night!=null){
            tUserDateDataEntityWrapper.eq("night",night).eq("date",date);
        }

        tUserDateDataEntityWrapper.setSqlSelect("id","date","night");
        List<TUserDateData> tUserDateData = dateDataService.selectList(tUserDateDataEntityWrapper);
        for (TUserDateData tUserDateDatum : tUserDateData) {
            tUserDateDatum.setTUserDataArray(new TUserData[]{});
        }
        PageInfo<TUserDateData> info=new PageInfo<>(tUserDateData);
        System.err.println(info);

        return R.ok(info);

    }

    @PostMapping("/api/clear")
    @ApiOperation(value = "设备clear", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R clear(String serNum) {
        //获取当天18点的时间
        redisService.setCacheObject("CLEAR:"+serNum, new Date());

        return R.ok();


    }

    @PostMapping("/api/ifclear")
    @ApiOperation(value = "设备是否需要clear", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R ifclear(String serNum) {
        //获取当天18点的时间
        Date cacheObject = redisService.getCacheObject("CLEAR:"+serNum);

        if (cacheObject!=null){
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.HOUR_OF_DAY, 18);
            calendar.set(Calendar.MINUTE, 0);
            calendar.set(Calendar.SECOND, 0);
            calendar.set(Calendar.MILLISECOND, 0);

            Date dateAt1800 = calendar.getTime();
            if (cacheObject.before(dateAt1800)){
                return R.ok(false);
            }else {
                return R.ok(true);
            }
        }else {
            return R.ok(true);
        }
    }





    @PostMapping("/api/link")
    @ApiOperation(value = "设备连接断开", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R link(@RequestBody LinkQuery linkQuery) {
        TDevice serNum = deviceService.selectOne(new EntityWrapper<TDevice>().eq("serNum", linkQuery.getSerNum()));
        serNum.setStatus(linkQuery.getStatus());
        deviceService.updateById(serNum);
        if (linkQuery.getStatus()==0){
            Long timestamp = new Date().getTime();
            redisService.setCacheObject(linkQuery.getSerNum(), timestamp.toString());
        }
        return R.ok();


    }

    @PostMapping("/api/last")
    @ApiOperation(value = "获取上次断开时间", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R last(String serNum) {
        String date = (String)redisService.getCacheObject(serNum);
        return R.ok(date);


    }


    @PostMapping("/api/datadetail")
    @ApiOperation(value = "检测记录详情", tags = {"App接口"}, notes = "")
    @ResponseBody
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R<TUserDateData> datadetail(HttpServletRequest request,Integer dataId) {
        TUserDateData tUserDateData = dateDataService.selectById(dataId);


        ObjectMapper mapper = new ObjectMapper();
        TUserData[] tUserDataArray = new TUserData[]{};
        try {
            // 将JSON字符串转换为TUserData数组
            tUserDataArray = mapper.readValue(tUserDateData.getData(), TUserData[].class);
            for (TUserData tUserData : tUserDataArray) {
                tUserData.setTime(tUserData.getDetectionTime().getTime());
            }
            tUserDateData.setTUserDataArray(tUserDataArray);
            // 打印转换后的数组，以便验证
            System.out.println(Arrays.toString(tUserDataArray));
        } catch (Exception e) {
            e.printStackTrace();
        }
        tUserDateData.setData(null);

        return R.ok(tUserDateData);

    }

    @Autowired
    private ITUserDataService userDataService;

    @ResponseBody
    @PostMapping("/api/pulldata")
    @ApiOperation(value = "推送数据", tags = {"App接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public R pulldata(HttpServletRequest request, @RequestParam("file") MultipartFile file) throws ParseException, JsonProcessingException {
        Integer uid =  redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
        List<TUserData> data = new ArrayList<>();

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Workbook book = WoUtil.ImportFile(file);
        Sheet sh = book.getSheetAt(0);   //获取到第一个表
        for (int i = 1; i <= sh.getLastRowNum(); i++) {
            Row row = sh.getRow(i);


            Cell cell2 = row.getCell(2);  //所属加盟商[提示:加盟车辆选填]
            Integer two = null;
            if (SinataUtil.isNotEmpty(cell2)) {
                two = (int)cell2.getNumericCellValue();
            }


            Cell cell4 = row.getCell(4);  //服务模式:出租车[是/否]
            String four = null;
            if (SinataUtil.isNotEmpty(cell4)) {
                four = String.valueOf(cell4.getStringCellValue()).trim();
            }

            Cell cell5 = row.getCell(1);  // 服务模式: 出租车[是/否]
            Date five = null;
            int divisor = 5;
            if (SinataUtil.isNotEmpty(cell5)) {
                double numericValue = cell5.getNumericCellValue();
                long timestamp = (long) numericValue; // 如果数值是整数毫秒时间戳
                five = new Date(timestamp);
                long seconds = timestamp / 1000;

                // 判断秒数是否为divisor的倍数
                boolean isMultiple = seconds % divisor == 0;
                if (!isMultiple){
//                    continue;
                }
            } else {
                // 处理单元格为空的情况
            }
//            System.err.println("====");
            TUserData tUserData = new TUserData();
            tUserData.setUserId(uid);
            tUserData.setDetectionTime(five);
            tUserData.setPosition(four);
            tUserData.setShapeVariable(Integer.valueOf(two));
            data.add(tUserData);
        }




//        data = userDataService.selectList(null);
        Map<String, List<TUserData>> groupedData = data.stream()
                .collect(Collectors.groupingBy(
                        item -> {
                            LocalDateTime dateTime = item.getDetectionTime().toInstant()
                                    .atZone(ZoneId.systemDefault())
                                    .toLocalDateTime();
                            LocalTime timeOfDay = dateTime.toLocalTime();

                            String groupKey;
                            if (timeOfDay.isAfter(LocalTime.of(22, 0))) {
                                // 晚上时间，归入前一天
                                LocalDate previousDay = dateTime.toLocalDate();
                                groupKey = previousDay + " 晚上";
                            } else if (timeOfDay.isBefore(LocalTime.of(10, 0))) {
                                LocalDate previousDay = dateTime.toLocalDate().minusDays(1);

                                // 早上的时间，即00:00 - 10:00
                                groupKey = previousDay + " 晚上";
                            } else {
                                // 其余时间，即10:00 - 22:00
                                groupKey = dateTime.toLocalDate() + " 白天";
                            }
                            return groupKey;
                        }
                ));

        // 输出分组结果
        for (Map.Entry<String, List<TUserData>> entry : groupedData.entrySet()) {
            System.out.println("Group: " + entry.getKey());
            String[] s = entry.getKey().split(" ");
            System.out.println("Data: " + entry.getValue());
            //判断是否已经存过数据，如果存过就在后面累加
            List<TUserDateData> tUserDateData = dateDataService.selectList(new EntityWrapper<TUserDateData>().eq("userId", uid).eq("date", s[0]).eq("night", "晚上".equals(s[1]) ? 1 : 0));
            //没有就直接save
            if (!tUserDateData.isEmpty()){
                //累加数据
                TUserDateData tUserDateData1 = tUserDateData.get(0);
                ObjectMapper mapper = new ObjectMapper();
                TUserData[] tUserDataArray = new TUserData[]{};
                try {
                    tUserDataArray = mapper.readValue(tUserDateData1.getData(), TUserData[].class);
                    System.out.println(Arrays.toString(tUserDataArray));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                List<TUserData> list = new ArrayList<>(); // 初始化一个空的 ArrayList
                list.addAll(Arrays.asList(tUserDataArray)); // 将原始数组添加到列表中
                List<TUserData> value = entry.getValue();
                list.addAll(value);
                String jsonInString = mapper.writeValueAsString(list);
                tUserDateData1.setData(jsonInString);
                dateDataService.updateById(tUserDateData1);
            }else {
                TUserDateData tUserDateData2 = new TUserDateData();
                ObjectMapper mapper = new ObjectMapper();
                try {
                    // 将TUserData数组转换为JSON字符串
                    String jsonInString = mapper.writeValueAsString(entry.getValue());
                    System.out.println(jsonInString);
                    tUserDateData2.setData(jsonInString);
                    tUserDateData2.setNight("晚上".equals(s[1]) ? 1 : 0);
                    tUserDateData2.setUserId(uid);
                    tUserDateData2.setDate(s[0]);
                    dateDataService.insert(tUserDateData2);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }



        return R.ok();


    }



    @Autowired
    private ITUserDateDataService dateDataService;
    @ResponseBody
    @PostMapping("/base/putdata")
    @ApiOperation(value = "测试用接口", tags = {"App接口"}, notes = "")
    public R<TDevice> putdata(HttpServletRequest request){
        // 创建一个Random对象用于生成随机数
        Random random = new Random();

        // 计算总秒数，现在每隔10秒生成一条数据
        int totalSeconds = 24 * 60 * 6; // 一天内每10秒一条数据

        // 创建一个TUserData对象数组
        TUserData[] tUserDataArray = new TUserData[totalSeconds];

        // 生成并添加数据到数组中
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        int shapeVariable = 0; // 初始化shapeVariable
        for (int i = 0; i < totalSeconds; i++) {
            // 设置检测时间为当前时间加上i*10秒
            calendar.setTime(new Date());
            calendar.add(Calendar.SECOND, i * 10);
            Date detectionTime = calendar.getTime();

            // 每10条数据shapeVariable才变化一次
            if (i % 10 == 0) {
                shapeVariable = random.nextInt(200) + 1; // 生成1到200之间的随机整数
            }

            // 假设userId也是1到100之间的随机整数
            Integer userId = random.nextInt(100) + 1;

            TUserData dataPoint = new TUserData();
            dataPoint.setDetectionTime(detectionTime);
            dataPoint.setShapeVariable(shapeVariable);

            tUserDataArray[i] = dataPoint;

        }

        // 打印前10个数据点的时间戳和shapeVariable以验证
        for (int i = 0; i < 10; i++) {
            System.out.println("Detection Time: " + sdf.format(tUserDataArray[i].getDetectionTime()));
            System.out.println("Shape Variable: " + tUserDataArray[i].getShapeVariable());
            System.out.println("-------------");
        }
        String str = Arrays.stream(tUserDataArray)
                .map(TUserData::toString)
                .collect(Collectors.joining(", ", "[", "]"));
        TUserDateData tUserDateData = new TUserDateData();
        tUserDateData.setDate("2024-07-15");
        tUserDateData.setUserId(1);

        ObjectMapper mapper = new ObjectMapper();
        try {
            // 将TUserData数组转换为JSON字符串
            String jsonInString = mapper.writeValueAsString(tUserDataArray);
            System.out.println(jsonInString);
            tUserDateData.setData(jsonInString);

        } catch (Exception e) {
            e.printStackTrace();
        }

        dateDataService.insert(tUserDateData);

        return R.ok();
    }



}