/*
 *    Copyright (c) 2018-2025, lengleng All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 * Neither the name of the yifu4cloud.com developer nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 * Author: lengleng (wangiegie@gmail.com)
 */
package com.yifu.cloud.plus.v1.nginx.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ArrayUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.read.metadata.holder.ReadRowHolder;
import com.alibaba.excel.util.ListUtils;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.gson.Gson;
import com.yifu.cloud.plus.v1.nginx.entity.NginxLog;
import com.yifu.cloud.plus.v1.nginx.mapper.NginxLogMapper;
import com.yifu.cloud.plus.v1.nginx.service.NginxLogService;
import com.yifu.cloud.plus.v1.nginx.vo.NginxLogSearchVo;
import com.yifu.cloud.plus.v1.nginx.vo.NginxLogVo;
import com.yifu.cloud.plus.v1.yifu.common.core.constant.CommonConstants;
import com.yifu.cloud.plus.v1.yifu.common.core.util.*;
import com.yifu.cloud.plus.v1.yifu.common.mybatis.base.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 
 *
 * @author fxj
 * @date 2024-02-27 16:17:54
 */
@AllArgsConstructor
@Log4j2
@Service
public class NginxLogServiceImpl extends ServiceImpl<NginxLogMapper, NginxLog> implements NginxLogService {
    /**
     * 简单分页查询
     * @param nginxLog 
     * @return
     */
    @Override
    public IPage<NginxLog> getNginxLogPage(Page<NginxLog> page, NginxLogSearchVo nginxLog){
        return baseMapper.getNginxLogPage(page,nginxLog);
    }

    /**
     * 批量导出
     * @param searchVo
     * @return
     */
    @Override
    public void listExport(HttpServletResponse response, NginxLogSearchVo searchVo){
        String fileName = "批量导出" + DateUtil.getThisTime() + ".xlsx";
        //获取要导出的列表
        List<NginxLog> list = new ArrayList<>();
        long count = noPageCountDiy(searchVo);
        ServletOutputStream out = null;
        try {
            out = response.getOutputStream();
            response.setContentType(CommonConstants.MULTIPART_FORM_DATA);
            response.setCharacterEncoding("utf-8");
            response.setHeader(CommonConstants.CONTENT_DISPOSITION, CommonConstants.ATTACHMENT_FILENAME + URLEncoder.encode(fileName  , CommonConstants.UTF8));
            // 这里 需要指定写用哪个class去写，然后写到第一个sheet，然后文件流会自动关闭
            //EasyExcel.write(out, TEmpBadRecord.class).sheet("不良记录").doWrite(list);
            ExcelWriter  excelWriter = EasyExcel.write(out, NginxLog.class).build();
            int index = 0;
            if (count >  CommonConstants.ZERO_INT){
                for (int i = 0; i <= count; ) {
                    // 获取实际记录
                    searchVo.setLimitStart(i);
                    searchVo.setLimitEnd(CommonConstants.EXCEL_EXPORT_LIMIT);
                    list = noPageDiy(searchVo);
                    if (Common.isNotNull(list)){
                        ExcelUtil<NginxLog> util = new ExcelUtil<>(NginxLog.class);
                        for (NginxLog vo:list){
                            util.convertEntity(vo,null,null,null);
                        }
                    }
                    if (Common.isNotNull(list)){
                        WriteSheet writeSheet = EasyExcel.writerSheet(""+index).build();
                        excelWriter.write(list,writeSheet);
                        index++;
                    }
                    i = i + CommonConstants.EXCEL_EXPORT_LIMIT;
                    if (Common.isNotNull(list)){
                        list.clear();
                    }
                }
            }else {
                WriteSheet writeSheet = EasyExcel.writerSheet(""+index).build();
                excelWriter.write(list,writeSheet);
            }
            if (Common.isNotNull(list)){
                list.clear();
            }
            out.flush();
            excelWriter.finish();
        }catch (Exception e){
            log.error("执行异常" ,e);
        }finally {
            try {
                if (null != out) {
                    out.close();
                }
            } catch (IOException e) {
                log.error("执行异常", e);
            }
        }
    }

    @Override
    public List<NginxLog> noPageDiy(NginxLogSearchVo searchVo) {
        LambdaQueryWrapper<NginxLog> wrapper = buildQueryWrapper(searchVo);
        List<String> idList = Common.getList(searchVo.getIds());
        if (Common.isNotNull(idList)){
            wrapper.in(NginxLog::getId,idList);
        }
        if (searchVo.getLimitStart() >= 0 && searchVo.getLimitEnd() > 0){
            wrapper.last(" limit "+ searchVo.getLimitStart() +","+ searchVo.getLimitEnd());
        }
        wrapper.orderByDesc(BaseEntity::getCreateTime);
        return baseMapper.selectList(wrapper);
    }

	private  Long noPageCountDiy(NginxLogSearchVo searchVo) {
        LambdaQueryWrapper<NginxLog> wrapper = buildQueryWrapper(searchVo);
        List<String> idList = Common.getList(searchVo.getIds());
        if (Common.isNotNull(idList)){
            wrapper.in(NginxLog::getId,idList);
        }
        return baseMapper.selectCount(wrapper);
    }

    private LambdaQueryWrapper buildQueryWrapper(NginxLogSearchVo entity){
        LambdaQueryWrapper<NginxLog> wrapper = Wrappers.lambdaQuery();
        if (ArrayUtil.isNotEmpty(entity.getCreateTimes())) {
            wrapper.ge(NginxLog::getCreateTime, entity.getCreateTimes()[0])
                    .le(NginxLog::getCreateTime,
                            entity.getCreateTimes()[1]);
        }
        if (Common.isNotNull(entity.getCreateName())){
            wrapper.eq(NginxLog::getCreateName,entity.getCreateName());
        }
        return wrapper;
    }

    @Override
    public R<List<ErrorMessage>> importDiy(InputStream inputStream) {
        List<ErrorMessage> errorMessageList = new ArrayList<>();
        ExcelUtil<NginxLogVo> util1 = new ExcelUtil<>(NginxLogVo.class);;
        // 写法2：
        // 匿名内部类 不用额外写一个DemoDataListener
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        try {
            EasyExcel.read(inputStream, NginxLogVo.class, new ReadListener<NginxLogVo>() {
                /**
                 * 单次缓存的数据量
                 */
                public static final int BATCH_COUNT = CommonConstants.BATCH_COUNT;
                /**
                 *临时存储
                 */
                private List<NginxLogVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);

                @Override
                public void invoke(NginxLogVo data, AnalysisContext context) {
                    ReadRowHolder readRowHolder = context.readRowHolder();
                    Integer rowIndex = readRowHolder.getRowIndex();
                    data.setRowIndex(rowIndex+1);
                    ErrorMessage errorMessage = util1.checkEntity(data, data.getRowIndex());
                    if (Common.isNotNull(errorMessage)){
                        errorMessageList.add(errorMessage);
                    }else {
                        cachedDataList.add(data);
                    }
                    if (cachedDataList.size() >= BATCH_COUNT) {
                        saveData();
                        // 存储完成清理 list
                        cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
                    }
                }
                @Override
                public void doAfterAllAnalysed(AnalysisContext context) {
                    saveData();
                }

                /**
                 * 加上存储数据库
                 */
                private void saveData() {
                    log.info("{}条数据，开始存储数据库！", cachedDataList.size());
                    importNginxLog(cachedDataList,errorMessageList);
                    log.info("存储数据库成功！");
                }
            }).sheet().doRead();
        }catch (Exception e){
            log.error(CommonConstants.IMPORT_DATA_ANALYSIS_ERROR,e);
            return R.failed(CommonConstants.IMPORT_DATA_ANALYSIS_ERROR);
        }
        return  R.ok(errorMessageList);
    }
    private void importNginxLog(List<NginxLogVo> excelVOList, List<ErrorMessage> errorMessageList) {
        // 个性化校验逻辑
        ErrorMessage errorMsg;
        // 执行数据插入操作 组装
        for (int i = 0; i < excelVOList.size(); i++) {
            NginxLogVo excel = excelVOList.get(i);
            // 数据合法情况 TODO

            // 插入
            insertExcel(excel);
            errorMessageList.add(new ErrorMessage(excel.getRowIndex(),CommonConstants.SAVE_SUCCESS));
        }
    }
    /**
     * 插入excel bad record
     */
    private void insertExcel(NginxLogVo excel) {
        NginxLog insert = new NginxLog();
        BeanUtil.copyProperties(excel, insert);
        this.save(insert);
    }
	@Async
	@Override
	public void readAndWriteLogAsys(){
		ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();

		// 创建一个Runnable对象来表示需要执行的任务
		Runnable task = new Runnable() {
			@Override
			public void run() {
				// 添加自己想要执行的逻辑代码
				log.info("nginx-log read:"+ DateUtil.getCurrentTimestamp());
				readAndWriteLog();
			}
		};

		// 调度任务并指定初始延迟为0秒，然后每隔1小时重复执行一次
		executor.scheduleAtFixedRate(task, 0, TimeUnit.HOURS.toMillis(1), TimeUnit.MILLISECONDS);

		// 等待程序结束前保持主线程运行状态
		try {
			Thread.sleep(Long.MAX_VALUE);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		// 关闭executor服务
		executor.shutdown();
	}

	@Override
	public void readAndWriteLog() {
		FileInputStream fis = null;
		BufferedReader br = null;
		try {
			// 读取JSON日志文件
			//fis = new FileInputStream("C:\\nginx.log");
			fis = new FileInputStream("/app/logs/nginx-log-"+DateUtil.dateIncreaseByHour(new Date(),0,DateUtil.DATETIME_PATTERN_HOUR)+".log");
			br = new BufferedReader(new InputStreamReader(fis));
			String line;
			while ((line = br.readLine()) != null) {
				// 解析JSON数据
				parseJson(line);
			}
			br.close();
		} catch (IOException e) {
			log.error("读取nginx日志文件异常"+e.getMessage());
		}finally {
			if (Common.isNotNull(br)){
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (Common.isNotNull(fis)){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	private void parseJson(String json) {
		// 解析JSON数据的代码
		Gson gson = new Gson();
		NginxLog logEntry = gson.fromJson(json, NginxLog.class);
		if (null != logEntry){
			baseMapper.insert(logEntry);
		}
	}


}
