import { useFileStore } from '@kevisual/use-config/file-store';
import http from 'node:http';
import fs from 'fs';
import Busboy from 'busboy';
import { app, minioClient } from '@/app.ts';

import { bucketName } from '@/modules/minio.ts';
import { getContentType } from '@/utils/get-content-type.ts';
import { User } from '@/models/user.ts';
import { getContainerById } from '@/routes/container/module/get-container-file.ts';
import { router, error, checkAuth, writeEvents } from './router.ts';
import './index.ts';
import { handleRequest as PageProxy } from './page-proxy.ts';
import path from 'path';
import { createWriteStream } from 'fs';
import { pipeBusboy } from '@/modules/fm-manager/pipe-busboy.ts';
const cacheFilePath = useFileStore('cache-file', { needExists: true });

router.get('/api/app/upload', async (req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Upload API is ready');
});

router.post('/api/app/upload', async (req, res) => {
  if (res.headersSent) return; // 如果响应已发送，不再处理
  res.writeHead(200, { 'Content-Type': 'application/json' });
  const { tokenUser, token } = await checkAuth(req, res);
  if (!tokenUser) return;

  // 使用 busboy 解析 multipart/form-data
  const busboy = Busboy({ headers: req.headers, preservePath: true });
  const fields: any = {};
  const files: any = [];
  const filePromises: Promise<void>[] = [];
  let bytesReceived = 0;
  let bytesExpected = parseInt(req.headers['content-length'] || '0');

  busboy.on('field', (fieldname, value) => {
    fields[fieldname] = value;
  });

  busboy.on('file', (fieldname, fileStream, info) => {
    const { filename, encoding, mimeType } = info;
    const tempPath = path.join(cacheFilePath, `${Date.now()}-${Math.random().toString(36).substring(7)}`);
    const writeStream = createWriteStream(tempPath);

    const filePromise = new Promise<void>((resolve, reject) => {
      fileStream.on('data', (chunk) => {
        bytesReceived += chunk.length;
        if (bytesExpected > 0) {
          const progress = (bytesReceived / bytesExpected) * 100;
          console.log(`Upload progress: ${progress.toFixed(2)}%`);
          const data = {
            progress: progress.toFixed(2),
            message: `Upload progress: ${progress.toFixed(2)}%`,
          };
          writeEvents(req, data);
        }
      });

      fileStream.pipe(writeStream);

      writeStream.on('finish', () => {
        files.push({
          filepath: tempPath,
          originalFilename: filename,
          mimetype: mimeType,
        });
        resolve();
      });

      writeStream.on('error', (err) => {
        reject(err);
      });
    });

    filePromises.push(filePromise);
  });

  busboy.on('finish', async () => {
    // 等待所有文件写入完成
    try {
      await Promise.all(filePromises);
    } catch (err) {
      console.error(`File write error: ${err.message}`);
      res.end(error(`File write error: ${err.message}`));
      return;
    }
    const clearFiles = () => {
      files.forEach((file: any) => {
        if (file?.filepath && fs.existsSync(file.filepath)) {
          fs.unlinkSync(file.filepath);
        }
      });
    };

    // 检查是否有文件上传
    if (files.length === 0) {
      res.end(error('files is required'));
      return;
    }

    let appKey,
      version,
      username = '';
    const { appKey: _appKey, version: _version, username: _username } = fields;
    if (Array.isArray(_appKey)) {
      appKey = _appKey?.[0];
    } else {
      appKey = _appKey;
    }
    if (Array.isArray(_version)) {
      version = _version?.[0];
    } else {
      version = _version;
    }
    if (Array.isArray(_username)) {
      username = _username?.[0];
    } else if (_username) {
      username = _username;
    }
    if (username) {
      const user = await User.getUserByToken(token);
      const has = await user.hasUser(username, true);
      if (!has) {
        res.end(error('username is not found'));
        clearFiles();
        return;
      }
    }
    if (!appKey) {
      res.end(error('appKey is required'));
      clearFiles();
      return;
    }
    if (!version) {
      res.end(error('version is required'));
      clearFiles();
      return;
    }
    console.log('Appkey', appKey, version);

    // 逐个处理每个上传的文件
    const uploadResults = [];
    for (let i = 0; i < files.length; i++) {
      const file = files[i];
      const tempPath = file.filepath; // 文件上传时的临时路径
      const relativePath = file.originalFilename; // 保留表单中上传的文件名 (包含文件夹结构)
      // 比如 child2/b.txt
      const minioPath = `${username || tokenUser.username}/${appKey}/${version}/${relativePath}`;
      // 上传到 MinIO 并保留文件夹结构
      const isHTML = relativePath.endsWith('.html');
      await minioClient.fPutObject(bucketName, minioPath, tempPath, {
        'Content-Type': getContentType(relativePath),
        'app-source': 'user-app',
        'Cache-Control': isHTML ? 'no-cache' : 'max-age=31536000, immutable', // 缓存一年
      });
      uploadResults.push({
        name: relativePath,
        path: minioPath,
      });
      fs.unlinkSync(tempPath); // 删除临时文件
    }
    // 受控
    const r = await app.call({
      path: 'app',
      key: 'uploadFiles',
      payload: {
        token: token,
        data: {
          appKey,
          version,
          username,
          files: uploadResults,
        },
      },
    });
    const data: any = {
      code: r.code,
      data: r.body,
    };
    if (r.message) {
      data.message = r.message;
    }
    res.end(JSON.stringify(data));
  });

  pipeBusboy(req, res, busboy);
});

router.get('/api/container/file/:id', async (req, res) => {
  const id = req.params.id;
  if (!id) {
    res.end(error('id is required'));
    return;
  }
  const container = await getContainerById(id);
  if (container.id) {
    const code = container.code;
    res.writeHead(200, {
      'Content-Type': 'application/javascript; charset=utf-8',
      'container-id': container.id,
    });
    res.end(code);
  } else {
    res.end(error('Container not found'));
  }

  res.writeHead(200, {
    'Content-Type': 'application/json',
  });
  res.end(JSON.stringify(container));
});

router.all('/api/nocodb-test/router', async (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });

  const param = await router.getSearch(req);
  const body = await router.getBody(req);

  const contentType = req.headers['content-type'] || '';
  console.log('Content-Type:', contentType);
  console.log('NocoDB test router called.', req.method, param, JSON.stringify(body, null));
  res.end(JSON.stringify({ message: 'NocoDB test router is working' }));
});
const simpleAppsPrefixs = [
  "/api/app/",
  "/api/micro-app/",
  "/api/events",
  "/api/s1/",
  "/api/container/",
  "/api/resource/",
  "/api/wxmsg",
  "/api/nocodb-test/"
];


export const handleRequest = async (req: http.IncomingMessage, res: http.ServerResponse) => {
  if (req.url?.startsWith('/api/router')) {
    // router自己管理
    return;
  }
  // if (req.url === '/MP_verify_NGWvli5lGpEkByyt.txt') {
  //   res.writeHead(200, { 'Content-Type': 'text/plain' });
  //   res.end('NGWvli5lGpEkByyt');
  //   return;
  // }
  if (req.url && simpleAppsPrefixs.some(prefix => req.url!.startsWith(prefix))) {
    // 简单应用路由处理
    // 设置跨域
    res.setHeader('Access-Control-Allow-Origin', '*');
    res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
    return router.parse(req, res);
  }
  // 其他请求交给页面代理处理
  return PageProxy(req, res);
};