import { WriteStream } from "fs";
import * as fs from "node:fs";
import * as path from "node:path";
import { randomUUID } from "node:crypto";
import {log, font_style} from "../types/utils/logger";

export interface LogHistoryRecord {
    id: string;
    timestamp: number;
    log: log[];
}

export interface _Logger {
    info(msg: string): void;
    success(msg: string): void;
    error(msg: string): void;
    warning(msg: string): void;
    tip(msg: string): void;
    custom(msg: string, font_color: string, font_style: font_style[]): void;
    log(log: log[]): void;
    get_recent_log(count: number): log[][];
    read_recent_log(count: number): Promise<LogHistoryRecord[]>;
    close(): Promise<void>;
}

export class Logger implements _Logger {
    // 单个日志文件的最大字节数（50M）
    private static readonly MAX_FILE_SIZE = 50 * 1024 * 1024;
    // 同一目录下保留的最大日志文件数
    private static readonly MAX_FILES = 10;
    // 日志文件名格式：year-month-day_log.log / year-month-day_log_{index}.log
    private static readonly LOG_FILE_REGEX = /^\d{4}-\d{2}-\d{2}_log(_\d+)?\.log$/;
    // 重建写入流的最大失败次数与重试延时
    private static readonly MAX_RECREATE_FAILURES = 10;
    private static readonly RECREATE_DELAY = 1000;

    private readonly log_dir: string;
    private writer!: WriteStream;
    // 当前日志所属日期（year-month-day）
    private day = '';
    // 当天的文件序号，0 为当天首个文件
    private index = 0;
    private size = 0;
    private write_queue: string[] = [];
    private in_flight_chunk: string | undefined;
    private writing = false;
    private recreate_failures = 0;
    private recreate_timer: NodeJS.Timeout | null = null;
    private stopped = false;
    private close_task: Promise<void> | undefined;
    constructor(log_dir: string) {
        this.log_dir = log_dir;
        this.day = this.format_day(new Date());
        this.open_writer();
    }

    private bind_writer_error(): void {
        this.writer.on('error', (err: NodeJS.ErrnoException) => {
            this.writing = false;
            // 仅处理文件不存在，重建写入流；其他错误交由后续写入重试
            if (err.code === 'ENOENT') {
                this.schedule_recreate();
            }
        });
    }

    // 合并并发错误，避免同一时刻重复创建
    private schedule_recreate(): void {
        if (this.stopped || this.recreate_timer !== null) {
            return;
        }
        this.recreate_timer = setTimeout(() => {
            this.recreate_timer = null;
            this.recreate_writer();
        }, Logger.RECREATE_DELAY);
        this.recreate_timer.unref();
    }

    // 重新创建写入流；累计失败达到上限后停止创建
    private recreate_writer(): void {
        if (this.stopped) {
            return;
        }
        this.recreate_failures++;
        if (this.recreate_failures >= Logger.MAX_RECREATE_FAILURES) {
            this.stopped = true;
            return;
        }
        try {
            this.open_writer();
            this.recreate_failures = 0;
            this.flush();
        } catch {
            // 创建失败，排到下一次重试
            this.schedule_recreate();
        }
    }

    private format_day(date: Date): string {
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, '0');
        const day = String(date.getDate()).padStart(2, '0');
        return `${year}-${month}-${day}`;
    }

    // 当天首个文件为 year-month-day_log.log，超出大小后追加序号
    private build_filename(day: string, index: number): string {
        return index === 0 ? `${day}_log.log` : `${day}_log_${index}.log`;
    }

    // 打开（或创建）当前应写入的文件，并接管已有大小
    private open_writer(): void {
        if (!fs.existsSync(this.log_dir)) {
            fs.mkdirSync(this.log_dir, { recursive: true });
        }
        const filename = this.build_filename(this.day, this.index);
        const file_path = path.join(this.log_dir, filename);
        try {
            this.size = fs.statSync(file_path).size;
        } catch {
            this.size = 0;
        }
        const broken = this.writer;
        if (broken) {
            try {
                broken.destroy();
            } catch {
                // 忽略已销毁流抛出的异常
            }
        }
        this.writer = fs.createWriteStream(file_path, {flags: 'a'});
        this.bind_writer_error();
        this.prune_files(filename);
    }

    // 超出保留数量时删除最旧的日志文件（文件名按时间递增，保留当前文件）
    private prune_files(keep_filename: string): void {
        let entries: string[];
        try {
            entries = fs.readdirSync(this.log_dir)
                .filter(name => Logger.LOG_FILE_REGEX.test(name))
                .sort();
        } catch {
            return;
        }
        let excess = entries.length - Logger.MAX_FILES;
        for (const name of entries) {
            if (excess <= 0) break;
            if (name === keep_filename) continue;
            try {
                fs.rmSync(path.join(this.log_dir, name));
                excess--;
            } catch {
                // 删除失败则跳过，保留文件
            }
        }
    }

    // 跨天或写满时切换到新文件
    private ensure_writer(): void {
        const today = this.format_day(new Date());
        if (today !== this.day) {
            this.day = today;
            this.index = 0;
            this.open_writer();
            return;
        }
        if (this.size >= Logger.MAX_FILE_SIZE) {
            this.index++;
            this.open_writer();
        }
    }

    public info(message: any): log {        // 白色
        return {
            message,
            font_color: '#ffffff',
            font_style: ['normal']
        };
    }

    public success(message: any): log {     // 柔和绿
        return {
            message,
            font_color: '#8fb98f',
            font_style: ['normal']
        };
    }

    public warning(message: any): log {     // 柔和沙黄
        return {
            message,
            font_color: '#d1b478',
            font_style: ['normal']
        };
    }

    public error(message: any): log {       // 柔和玫红
        return {
            message,
            font_color: '#cf8e8e',
            font_style: ['normal']
        };
    }

    public tip(message: any): log {         // 柔和钢蓝
        return {
            message,
            font_color: '#8fb0c9',
            font_style: ['normal']
        };
    }

    public custom(message: any, font_color: string, font_style: font_style[]): log {
        return {
            message,
            font_color,
            font_style
        };
    }

    public log(log: log[]): void {
        if (this.stopped || log.length === 0) {
            return;
        }
        const data = {
            id: randomUUID(),
            timestamp: Date.now(),
            log
        }
        this.write_queue.push(`${JSON.stringify(data)}\n`);
        this.flush();
    }

    // 串行写入：上一条落盘后才写下一批，保证大量日志的顺序
    private flush(): void {
        if (this.writing || this.stopped) {
            return;
        }
        const chunk = this.write_queue.shift();
        if (chunk === undefined) {
            return;
        }
        this.ensure_writer();
        this.writing = true;
        this.in_flight_chunk = chunk;
        this.writer.write(chunk, (err) => {
            if (this.in_flight_chunk === chunk) this.in_flight_chunk = undefined;
            this.writing = false;
            if (err) {
                if (this.stopped) return;
                // 写入失败则回队，等待重建写入流后重试，避免丢日志
                this.write_queue.unshift(chunk);
                return;
            }
            this.size += Buffer.byteLength(chunk);
            this.flush();
        });
    }

    public close(): Promise<void> {
        if (this.close_task) return this.close_task;
        this.stopped = true;
        if (this.recreate_timer) clearTimeout(this.recreate_timer);
        this.recreate_timer = null;
        this.close_task = new Promise<void>(resolve => {
            if (this.writer.closed) {
                resolve();
                return;
            }
            this.writer.once('close', () => {
                this.write_queue.length = 0;
                resolve();
            });
            this.writer.end(this.write_queue.join(''));
        });
        return this.close_task;
    }

    private static parse_history_record(line: string): LogHistoryRecord | undefined {
        try {
            const record = JSON.parse(line);
            if (record && typeof record.id === 'string' &&
                typeof record.timestamp === 'number' && Number.isFinite(record.timestamp) &&
                Array.isArray(record.log)) {
                return record;
            }
        } catch {
            // Ignore corrupt or incomplete records.
        }
        return undefined;
    }

    public static async read_recent_log(log_dir: string, count: number): Promise<LogHistoryRecord[]> {
        if (!Number.isFinite(count) || count < 1) return [];
        count = Math.floor(count);
        let names: string[];
        try {
            names = (await fs.promises.readdir(log_dir))
                .filter(name => Logger.LOG_FILE_REGEX.test(name))
                .sort((a, b) => {
                    const date_order = a.slice(0, 10).localeCompare(b.slice(0, 10));
                    return date_order || Number(a.match(/_(\d+)\.log$/)?.[1] ?? 0) -
                        Number(b.match(/_(\d+)\.log$/)?.[1] ?? 0);
                }).reverse();
        } catch {
            return [];
        }
        const records: LogHistoryRecord[] = [];
        const max_line_bytes = 1024 * 1024;
        let budget = 16 * max_line_bytes;
        for (const name of names) {
            if (records.length >= count || budget <= 0) break;
            let file: fs.promises.FileHandle | undefined;
            try {
                file = await fs.promises.open(path.join(log_dir, name), 'r');
                let position = (await file.stat()).size;
                let pending = Buffer.alloc(0);
                let skipping = false;
                const accept = (line: Buffer) => {
                    if (line.length > max_line_bytes) return;
                    const record = Logger.parse_history_record(line.toString('utf8'));
                    if (record) records.push(record);
                };
                while (position > 0 && records.length < count && budget > 0) {
                    const length = Math.min(position, 64 * 1024, budget);
                    position -= length;
                    budget -= length;
                    const chunk = Buffer.allocUnsafe(length);
                    const {bytesRead} = await file.read(chunk, 0, length, position);
                    const data = Buffer.concat([chunk.subarray(0, bytesRead), pending]);
                    let end = data.length;
                    let newline: number;
                    while ((newline = data.lastIndexOf(10, end - 1)) >= 0 && end > 0) {
                        if (!skipping) accept(data.subarray(newline + 1, end));
                        skipping = false;
                        end = newline;
                        if (records.length >= count) break;
                    }
                    // Discard oversized lines until their preceding newline is found.
                    if (skipping || end > max_line_bytes) {
                        pending = Buffer.alloc(0);
                        skipping = true;
                    } else {
                        pending = Buffer.from(data.subarray(0, end));
                    }
                }
                if (position === 0 && !skipping && records.length < count) accept(pending);
            } catch {
                // Rotation or removal can race a history read; continue with older files.
            } finally {
                if (file) await file.close();
            }
        }
        return records.reverse();
    }

    public async read_recent_log(count: number): Promise<LogHistoryRecord[]> {
        if (!Number.isFinite(count) || count < 1) return [];
        count = Math.floor(count);
        const snapshot = [this.in_flight_chunk, ...this.write_queue]
            .filter((chunk): chunk is string => chunk !== undefined)
            .map(chunk => Logger.parse_history_record(chunk))
            .filter((record): record is LogHistoryRecord => record !== undefined);
        const snapshot_ids = new Set(snapshot.map(record => record.id));
        const records = (await Logger.read_recent_log(this.log_dir, count))
            .filter(record => !snapshot_ids.has(record.id));
        const ids = new Set(records.map(record => record.id));
        for (const record of snapshot) {
            if (ids.has(record.id)) continue;
            ids.add(record.id);
            records.push(record);
        }
        return records.slice(-count);
    }

    // 读取最近的 count 条日志，跨文件时自动按时间顺序拼接
    public get_recent_log(count: number): log[][] {
        if (count <= 0) {
            return [];
        }
        let names: string[];
        try {
            names = fs.readdirSync(this.log_dir)
                .filter(name => Logger.LOG_FILE_REGEX.test(name))
                .sort()
                .reverse();
        } catch {
            return [];
        }
        const lines: string[] = [];
        for (const name of names) {
            let content: string;
            try {
                content = fs.readFileSync(path.join(this.log_dir, name), 'utf-8');
            } catch {
                continue;
            }
            const file_lines = content.split('\n').filter(line => line.length > 0);
            for (let i = file_lines.length - 1; i >= 0 && lines.length < count; i--) {
                lines.push(file_lines[i]);
            }
            if (lines.length >= count) {
                break;
            }
        }
        // 收集顺序为从新到旧，反转恢复为时间正序
        lines.reverse();
        return lines.map(line => {
            try {
                return JSON.parse(line);
            } catch {
                return line;
            }
        });
    }
}