// 添加账本
import {
    getFileBymd5,
    searchFileByPath,
    author_insert,
    get_author_info,
} from "#db";
import logger from "#logger";
import path from "node:path";
import fs from "node:fs";
import express from "express";
import {EPub} from "epub2";
import {v4 as uuidv4} from "uuid";
import {dirExists, isFileSync, isDir, waittime} from "#utils";

import {saveImgs, calculateMD5} from "./image.js";
import {htmlParser, saveMateInfo} from "./txt.js";
import {saveAllCSS} from "./style.js";
import {saveAllFount} from "./font.js";
import {saveToc} from "./toc.js";

const router = express.Router();

// middleware that is specific to this router
router.use(function timeLog(req, res, next) {
    next();
});
// define the home page route
router.get("/", async function (req, res) {
    res.send("epub types");
});

// define the about route
router.get("/about", function (req, res) {
    res.send("About types");
});

router.get("/html/:fileId", async function (req, res) {
    const fileId = req.params.fileId; // 获取 fileId 参数
    logger.info(`Found ${fileId}`);
    const fileRow = await getFileBymd5(fileId);
    
    if (!fileRow) {
        return res.status(404).send("文件查询失败");
    }
    const uploadPath =
        "./base_files/" + fileRow.book_id + "/Text/" + fileId + ".html";
    console.log(46, fileRow);
    
    const filePath = path.resolve(uploadPath);
    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
        return res.status(404).send("服务器中不存在该文件");
    }
    
    // 返回文件
    res.setHeader("Content-Type", fileRow.mimetype);
    res.sendFile(filePath);
});

router.get("/img/:fileId", async function (req, res) {
    const fileId = req.params.fileId; // 获取 fileId 参数
    logger.info(`Found ${fileId}`);
    
    const fileRow = await getFileBymd5(fileId);
    
    if (!fileRow) {
        return res.status(404).send("文件查询失败");
    }
    const uploadPath = "./base_files/" + fileRow.book_id + "/image/" + fileId;
    const filePath = path.resolve(uploadPath);
    
    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
        return res.status(404).send("服务器中不存在该文件");
    }
    
    // 返回文件
    res.setHeader("Content-Type", fileRow.mimetype);
    res.sendFile(filePath);
});

router.get("/css/:fileId", async function (req, res) {
    const fileId = req.params.fileId; // 获取 fileId 参数
    logger.info(`Found ${fileId}`);
    const fileRow = await getFileBymd5(fileId);
    
    if (!fileRow) {
        return res.status(404).send("文件查询失败");
    }
    const uploadPath =
        "./base_files/" + fileRow.book_id + "/style/" + fileId + ".css";
    
    const filePath = path.resolve(uploadPath);
    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
        return res.status(404).send("服务器中不存在该文件");
    }
    
    // 返回文件
    res.setHeader("Content-Type", fileRow.mimetype);
    res.sendFile(filePath);
});

// define the about route
router.put("/", async function (req, res) {
    let sampleFile;
    let uploadPath;
    let epubData;
    let zipEpubExtract;
    let epubFilePath;
    let epub;
    
    if (!req.files || Object.keys(req.files).length === 0) {
        return res.status(400).send("No files were uploaded.");
    }
    
    sampleFile = req.files.file;
    
    let file_md5 = sampleFile.md5;
    uploadPath = `./base_files/${file_md5}/`;
    epubFilePath = uploadPath + sampleFile.md5 + ".epub";
    zipEpubExtract = uploadPath + "epub-extract/";
    
    dirExists(uploadPath);
    
    await waittime(200);
    
    const isFile = isFileSync(epubFilePath);
    
    // 移动上传文件至指定目录
    if (!isFile) {
        sampleFile.mv(epubFilePath, function (err) {
            console.log("移动上传文件至指定目录的反馈", err);
        });
        epubData = sampleFile.data;
    } else {
        epubData = fs.readFileSync(epubFilePath);
        file_md5 = await calculateMD5(epubFilePath);
    }
    
    /* 是否需要解压文件 */
    if (!(await isDir(zipEpubExtract))) {
        epub = await EPub.createAsync(epubData, null, "");
        dirExists(zipEpubExtract);
        epub.zip.admZip.extractAllTo(zipEpubExtract);
    } else {
        epub = await EPub.createAsync(epubData, null, "");
    }
    
    // 生成作者的数据
    let authorInfo = await get_author_info(epub.metadata.creator);
    let author_id = authorInfo.author_id;
    if (!authorInfo) {
        author_id = uuidv4();
        await author_insert({name: epub.metadata.creator, author_id: author_id});
    }
    /*
      1、读取图片信息
      2、替换文件中的图片内容
      3、存储html数据
      4、存储css数据
      5、存储章节数据
     */
    /*await saveMateInfo(epub, uploadPath, file_md5, author_id)
    logger.info('书籍的基础数据处理完毕')
    await saveImgs(epub, uploadPath, file_md5, author_id);
    logger.info('书籍的图片数据处理完毕')
    await saveAllFount(epub, uploadPath, file_md5, author_id);
    logger.info('书籍的字体数据处理完毕')
    await saveAllCSS(epub, uploadPath, file_md5, author_id);
    logger.info('书籍的css数据处理完毕')
    // 存储html数据
    await htmlParser(epub, zipEpubExtract, file_md5, author_id);
    logger.info('书籍的章节数据处理完毕')*/
    // 章节数据
    await saveToc(epub, zipEpubExtract, file_md5, author_id);
    logger.info('书籍的目录处理完毕')
    logger.info('书籍处理完毕')
    res.send("书籍处理完毕");
});

export default router;