/*
METADATA
{
    "name": "jmcomic_downloader",

    "display_name": {
        "zh": "JMComic 下载器",
        "en": "JMComic Downloader"
    },
    "description": { "zh": "提供JMComic漫画下载功能，支持搜索、获取信息和下载，包括对新漫画的图片反爬解码。", "en": "JMComic downloader: search comics, fetch details, and download albums. Includes anti-crawling image decoding for newer comics." },
    "category": "Media",
    "tools": [
        {
            "name": "main",
            "description": { "zh": "运行一个内置的测试函数，以验证JMComic工具的基本功能（搜索和获取信息）是否正常工作。", "en": "Run a built-in test to verify basic JMComic functionality (search and info retrieval)." },
            "parameters": []
        },
        {
            "name": "search_comics",
            "description": { "zh": "搜索JMComic漫画", "en": "Search JMComic comics." },
            "parameters": [
                {
                    "name": "query",
                    "description": { "zh": "搜索关键词", "en": "Search keyword." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "page",
                    "description": { "zh": "页码 (默认: 1)", "en": "Page number (default: 1)." },
                    "type": "number",
                    "required": false
                },
                {
                    "name": "order_by",
                    "description": { "zh": "排序方式 (latest, view, picture, like, 默认: view)", "en": "Sort mode: latest/view/picture/like (default: view)." },
                    "type": "string",
                    "required": false
                },
                {
                    "name": "time",
                    "description": { "zh": "时间范围 (today, week, month, all, 默认: all)", "en": "Time range: today/week/month/all (default: all)." },
                    "type": "string",
                    "required": false
                }
            ]
        },
        {
            "name": "get_album_info",
            "description": { "zh": "获取漫画（本子）的详细信息", "en": "Get detailed information for a comic album." },
            "parameters": [
                {
                    "name": "album_id",
                    "description": { "zh": "漫画ID", "en": "Album ID." },
                    "type": "string",
                    "required": true
                }
            ]
        },
        {
            "name": "download_album",
            "description": { "zh": "下载指定ID的单本漫画，包含图片解码功能。", "en": "Download a single comic album by ID, including image decoding." },
            "parameters": [
                {
                    "name": "album_id",
                    "description": { "zh": "要下载的漫画ID", "en": "Album ID to download." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "download_dir",
                    "description": { "zh": "下载目录 (可选, 默认: /sdcard/Download/Operit/plugins/jmcomic_downloader/downloads)", "en": "Download directory (optional; default: /sdcard/Download/Operit/plugins/jmcomic_downloader/downloads)." },
                    "type": "string",
                    "required": false
                }
            ]
        },
        {
            "name": "batch_download_albums",
            "description": { "zh": "批量下载多本漫画，包含图片解码功能。", "en": "Batch download multiple comic albums, including image decoding." },
            "parameters": [
                {
                    "name": "album_ids",
                    "description": { "zh": "要下载的漫画ID列表，用逗号分隔", "en": "Comma-separated list of album IDs to download." },
                    "type": "string",
                    "required": true
                },
                {
                    "name": "download_dir",
                    "description": { "zh": "下载目录 (可选, 默认: /sdcard/Download/Operit/plugins/jmcomic_downloader/downloads)", "en": "Download directory (optional; default: /sdcard/Download/Operit/plugins/jmcomic_downloader/downloads)." },
                    "type": "string",
                    "required": false
                }
            ]
        }
    ],
    "enabledByDefault": false
}*/

// region Type Definitions
interface Album {
    id: string;
    title: string;
    author: string;
    scrambleId: number;
    episodeList: { id: string; title: string }[];
    length: number;
}

interface Photo {
    id: string;
    title: string;
    albumId: string;
    scrambleId: number;
    pageArr: string[];
    length: number;
}

interface SearchResultItem {
    id: string;
    title: string;
}

interface SearchResult {
    search_params: SearchParams;
    results: SearchResultItem[];
    total_results: number;
}

interface SearchParams {
    query: string;
    page?: number;
    order_by?: 'latest' | 'view' | 'picture' | 'like';
    time?: 'today' | 'week' | 'month' | 'all';
}

interface AlbumInfo {
    id: string;
    title: string;
    author: string;
    chapterCount: number;
    success: boolean;
}

interface DownloadResult {
    success: boolean;
    albumId: string;
    title?: string;
    downloadedFiles?: {
        directory: string | undefined;
        fileCount: number;
        files: string[];
    };
    error?: string;
}

interface BatchDownloadResult {
    success: boolean;
    albumId: string;
    title?: string;
    error?: string;
}

// endregion

const jmcomic = (function () {
    const DEFAULT_DOWNLOAD_DIR = `${getPluginConfigDir("jmcomic_downloader")}/downloads`;
    const TEST_DOWNLOAD_DIR = `${getPluginConfigDir("jmcomic_downloader")}/test_downloads`;

    // region Polyfill & Utils
    const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

    function normalizeBase64Input(value: string): string {
        const cleaned = String(value || '')
            .replace(/\s+/g, '')
            .replace(/-/g, '+')
            .replace(/_/g, '/');
        if (!cleaned) {
            return '';
        }
        const remainder = cleaned.length % 4;
        if (remainder === 1) {
            throw new Error('Invalid base64 string');
        }
        return remainder === 0 ? cleaned : cleaned + '='.repeat(4 - remainder);
    }

    function decodeBase64ToBytes(value: string): number[] {
        const normalized = normalizeBase64Input(value);
        const bytes: number[] = [];

        for (let i = 0; i < normalized.length; i += 4) {
            const c1 = normalized[i];
            const c2 = normalized[i + 1];
            const c3 = normalized[i + 2];
            const c4 = normalized[i + 3];

            const v1 = BASE64_ALPHABET.indexOf(c1);
            const v2 = BASE64_ALPHABET.indexOf(c2);
            const v3 = c3 === '=' ? 0 : BASE64_ALPHABET.indexOf(c3);
            const v4 = c4 === '=' ? 0 : BASE64_ALPHABET.indexOf(c4);

            if (v1 < 0 || v2 < 0 || (c3 !== '=' && v3 < 0) || (c4 !== '=' && v4 < 0)) {
                throw new Error('Invalid base64 string');
            }

            const chunk = (v1 << 18) | (v2 << 12) | (v3 << 6) | v4;
            bytes.push((chunk >> 16) & 0xff);
            if (c3 !== '=') {
                bytes.push((chunk >> 8) & 0xff);
            }
            if (c4 !== '=') {
                bytes.push(chunk & 0xff);
            }
        }

        return bytes;
    }

    function encodeBytesToBase64(bytes: number[]): string {
        let output = '';

        for (let i = 0; i < bytes.length; i += 3) {
            const b1 = bytes[i];
            const hasB2 = i + 1 < bytes.length;
            const hasB3 = i + 2 < bytes.length;
            const b2 = hasB2 ? bytes[i + 1] : 0;
            const b3 = hasB3 ? bytes[i + 2] : 0;
            const chunk = (b1 << 16) | (b2 << 8) | b3;

            output += BASE64_ALPHABET[(chunk >> 18) & 0x3f];
            output += BASE64_ALPHABET[(chunk >> 12) & 0x3f];
            output += hasB2 ? BASE64_ALPHABET[(chunk >> 6) & 0x3f] : '=';
            output += hasB3 ? BASE64_ALPHABET[chunk & 0x3f] : '=';
        }

        return output;
    }

    function decodeBase64Binary(value: string): string {
        return decodeBase64ToBytes(value)
            .map((byte) => String.fromCharCode(byte))
            .join('');
    }

    function encodeBase64Binary(value: string): string {
        const bytes: number[] = [];
        const input = String(value || '');
        for (let i = 0; i < input.length; i++) {
            bytes.push(input.charCodeAt(i) & 0xff);
        }
        return encodeBytesToBase64(bytes);
    }

    // Buffer a subset of Buffer functionality for base64 encoding/decoding
    const Buffer = {
        from: (str: string, encoding: string = 'utf8') => {
            if (encoding === 'base64') {
                return decodeBase64Binary(str);
            } else if (encoding === 'hex') {
                let s = '';
                for (let i = 0; i < str.length; i += 2) {
                    s += String.fromCharCode(parseInt(str.substr(i, 2), 16));
                }
                return s;
            }
            return str;
        },
        toString: (buf: string, encoding: string = 'utf8') => {
            if (encoding === 'base64') {
                return encodeBase64Binary(buf);
            } else if (encoding === 'hex') {
                let s = '';
                for (let i = 0; i < buf.length; i++) {
                    s += ('0' + buf.charCodeAt(i).toString(16)).slice(-2);
                }
                return s;
            }
            return buf;
        }
    };

    function joinPath(...segments: string[]): string {
        return segments.join('/').replace(/\/+/g, '/');
    }

    function dirname(filePath: string): string {
        const lastSlashPos = filePath.lastIndexOf('/');
        if (lastSlashPos === -1) {
            return ".";
        }
        if (lastSlashPos === 0) {
            return "/";
        }
        return filePath.substring(0, lastSlashPos);
    }

    async function ensureDirExists(dirPath: string): Promise<void> {
        if (!dirPath || dirPath === '/' || dirPath === '.') {
            return;
        }

        const dirExists = await Tools.Files.exists(dirPath);
        if (dirExists.exists) {
            return;
        }

        const parentDir = dirname(dirPath);
        await ensureDirExists(parentDir);

        const dirStillNotExists = await Tools.Files.exists(dirPath);
        if (!dirStillNotExists.exists) {
            await Tools.Files.mkdir(dirPath);
        }
    }

    function basename(filePath: string): string {
        return filePath.substring(filePath.lastIndexOf('/') + 1);
    }

    async function runTasksWithConcurrency<T>(tasks: (() => Promise<T>)[], limit: number): Promise<T[]> {
        const results: (T | Error)[] = new Array(tasks.length);
        let currentIndex = 0;

        async function runner(): Promise<void> {
            while (currentIndex < tasks.length) {
                const taskIndex = currentIndex++;
                if (taskIndex < tasks.length) {
                    try {
                        results[taskIndex] = await tasks[taskIndex]();
                    } catch (e: any) {
                        console.error(`并发任务 ${taskIndex} 执行失败: ${e.message}`);
                        results[taskIndex] = e;
                    }
                }
            }
        }

        const runners: Promise<void>[] = [];
        const numRunners = Math.min(limit, tasks.length);
        for (let i = 0; i < numRunners; i++) {
            runners.push(runner());
        }

        await Promise.all(runners);
        return results.filter(r => !(r instanceof Error)) as T[];
    }

    // endregion

    // region Constants and Classes from jmcomic
    const __version__ = '2.6.4-ts-adapted';

    function shuffleDomains(domains: string[]): string[] {
        const shuffled = [...domains];
        for (let i = shuffled.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
        }
        return shuffled;
    }

    const JmMagicConstants = {
        APP_TOKEN_SECRET: '18comicAPP',
        APP_TOKEN_SECRET_2: '18comicAPPContent',
        APP_DATA_SECRET: '185Hcomic3PAPP7R',
        APP_VERSION: '1.8.0',
        SCRAMBLE_220980: 220980,
        SCRAMBLE_268850: 268850,
        SCRAMBLE_421926: 421926
    };

    const JmModuleConfig = {
        PROT: 'https://',
        DOMAIN_API_LIST: shuffleDomains([
            'www.cdnmhwscc.vip',
            'www.cdnplaystation6.club',
            'www.cdnplaystation6.org',
            'www.cdnuc.vip',
            'www.cdn-mspjmapiproxy.xyz'
        ]),
        DOMAIN_IMAGE_LIST: shuffleDomains([
            'cdn-msp.jmapiproxy1.cc',
            'cdn-msp.jmapiproxy2.cc',
            'cdn-msp2.jmapiproxy2.cc',
            'cdn-msp3.jmapiproxy2.cc'
        ]),
        APP_HEADERS_TEMPLATE: {
            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',
            'X-Requested-With': 'com.jiaohua_browser',
            'user-agent': 'Mozilla/5.0 (Linux; Android 9; V1938CT Build/PQ3A.190705.11211812; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/91.0.4472.114 Safari/537.36',
        },
        APP_HEADERS_IMAGE: {
            'Accept': 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
            'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',
            'X-Requested-With': 'com.jiaohua_browser',
        }
    };

    class JmImageTool {
        static getNum(scrambleId: number | string, photoId: number | string, imageName: string): number {
            const scrambleIdNum = parseInt(scrambleId.toString());
            const photoIdNum = parseInt(photoId.toString());

            if (photoIdNum < scrambleIdNum) {
                return 0;
            } else if (photoIdNum < JmMagicConstants.SCRAMBLE_268850) {
                return 10;
            } else {
                const x = photoIdNum < JmMagicConstants.SCRAMBLE_421926 ? 10 : 8;

                const imageNameWithoutExt = this.getFileNameFromUrl(imageName, true);
                const s = `${photoIdNum}${imageNameWithoutExt}`;

                const hash = CryptoJS.MD5(s).toString();
                const lastChar = hash.charCodeAt(hash.length - 1);
                const num = lastChar % x;
                return (num * 2) + 2;
            }
        }

        static getFileNameFromUrl(url: string, withoutExtension: boolean = true): string {
            const queryIndex = url.indexOf('?');
            if (queryIndex !== -1) {
                url = url.substring(0, queryIndex);
            }
            const filename = basename(url);
            if (withoutExtension) {
                const lastDotIndex = filename.lastIndexOf('.');
                return lastDotIndex !== -1 ? filename.substring(0, lastDotIndex) : filename;
            }
            return filename;
        }

        static async decodeAndSave(num: number, imageBase64: string, decodedSavePath: string): Promise<void> {
            if (num === 0) {
                await Tools.Files.writeBinary(decodedSavePath, imageBase64);
                return;
            }

            let srcImage: Jimp.JimpWrapper | undefined = undefined;
            let resultImage: Jimp.JimpWrapper | undefined = undefined;
            const stripsToRelease: Jimp.JimpWrapper[] = [];

            try {
                srcImage = await Jimp.read(imageBase64);
                const w = await srcImage.getWidth();
                const h = await srcImage.getHeight();
                const over = h % num;

                resultImage = await Jimp.create(w, h);

                for (let i = 0; i < num; i++) {
                    let move = Math.floor(h / num);
                    let ySrc = h - (move * (i + 1)) - over;
                    let yDst = move * i;

                    if (i === 0) {
                        move += over;
                    } else {
                        yDst += over;
                    }

                    if (ySrc < 0 || move <= 0 || (ySrc + move > h)) continue;

                    const strip = await srcImage.crop(0, ySrc, w, move);
                    stripsToRelease.push(strip);
                    await resultImage.composite(strip, 0, yDst);
                }

                const decodedImageBase64 = await resultImage.getBase64(Jimp.MIME_JPEG);

                // 移除 "data:image/jpeg;base64," 前缀
                const pureBase64 = decodedImageBase64.substring(decodedImageBase64.indexOf(',') + 1);

                await Tools.Files.writeBinary(decodedSavePath, pureBase64);
            } catch (e: any) {
                console.error(`图片解码失败，将保存原始图片: ${e.message}`);
                await Tools.Files.writeBinary(decodedSavePath, imageBase64);
            } finally {
                if (srcImage) await srcImage.release();
                if (resultImage) await resultImage.release();
                for (const strip of stripsToRelease) {
                    await strip.release();
                }
            }
        }
    }

    class JmCryptoTool {
        static md5hex(key: string): string {
            return CryptoJS.MD5(key).toString();
        }

        static tokenAndTokenparam(ts: number, secret: string = JmMagicConstants.APP_TOKEN_SECRET): [string, string] {
            const tokenparam = `${ts},${JmMagicConstants.APP_VERSION}`;
            const token = this.md5hex(`${ts}${secret}`);
            return [token, tokenparam];
        }

        static decodeRespData(data: string, ts: number, secret: string = JmMagicConstants.APP_DATA_SECRET): string {
            try {
                // Revert to the standard CryptoJS usage pattern.
                // First, create the key from ts and secret using MD5.
                const keyHex = this.md5hex(`${ts}${secret}`);
                const key = CryptoJS.enc.Hex.parse(keyHex);

                // Then, call decrypt with the standard signature.
                const decrypted = CryptoJS.AES.decrypt(data, key, {
                    mode: CryptoJS.mode.ECB,
                    padding: CryptoJS.pad.Pkcs7
                });

                const decryptedText = decrypted.toString(CryptoJS.enc.Utf8);

                if (!decryptedText) {
                    throw new Error("AES decryption returned an empty result.");
                }
                return decryptedText;
            } catch (error: any) {
                console.error(`Underlying decryption error: ${error.message}`);
                throw new Error(`AES Decryption failed. Original error: ${error.message}`);
            }
        }
    }

    class JmApiResp {
        constructor(private resp: OkHttpResponse, private ts: number) { }

        get isSuccess(): boolean {
            return this.resp.isSuccessful();
        }

        get json(): any {
            try {
                return JSON.parse(this.resp.content);
            } catch (error: any) {
                throw new Error(`JSON解析失败: ${error.message}`);
            }
        }

        get isSuccessful(): boolean {
            return this.isSuccess && this.json.code === 200;
        }

        get encodedData(): string {
            return this.json.data;
        }

        get decodedData(): string {
            return JmCryptoTool.decodeRespData(this.encodedData, this.ts);
        }

        get resData(): any {
            if (!this.isSuccessful) {
                throw new Error(`API请求失败: code=${this.json.code}`);
            }
            const decoded = this.decodedData;
            try {
                if (typeof decoded !== 'string' || !decoded) {
                    throw new Error(`Cannot parse non-string or empty value. Type: ${typeof decoded}`);
                }
                return JSON.parse(decoded);
            } catch (error: any) {
                const preview = String(decoded || 'N/A').substring(0, 80);
                throw new Error(`Failed to parse decrypted response. Error: ${error.message}. Original data type was ${typeof decoded}.`);
            }
        }

        get modelData(): any {
            return this.resData;
        }
    }

    class DirRuleImpl {
        constructor(public baseDir: string) { }

        decideImageSaveDir(album: Album, photo: Photo): string {
            return joinPath(this.baseDir, this.sanitize(album.title));
        }

        decideAlbumRootDir(album: Pick<Album, 'title'>): string {
            return joinPath(this.baseDir, this.sanitize(album.title));
        }

        sanitize(name: string): string {
            return name.replace(/[\\?%*:|"<>]/g, '_');
        }
    }

    class JmOptionImpl {
        public dirRule: DirRuleImpl;
        constructor(baseDir: string = DEFAULT_DOWNLOAD_DIR) {
            this.dirRule = new DirRuleImpl(baseDir);
        }

        static default(baseDir: string = DEFAULT_DOWNLOAD_DIR): JmOptionImpl {
            return new JmOptionImpl(baseDir);
        }

        buildJmClient(): JmApiClientImpl {
            return new JmApiClientImpl();
        }
    }

    class JmApiClientImpl {
        private domainList: string[] = JmModuleConfig.DOMAIN_API_LIST;
        private retryTimes: number = 3;
        private client: OkHttpClient = OkHttp.newClient();

        private API_ALBUM = '/album';
        private API_CHAPTER = '/chapter';
        private API_SEARCH = '/search';
        private API_CATEGORIES_FILTER = '/categories/filter';

        async getAlbumDetail(albumId: string): Promise<Album> {
            const resp = await this.reqApi(`${this.API_ALBUM}?id=${albumId}`);
            const data = resp.resData;
            if (!data || !data.name) throw new Error(`本子 ${albumId} 不存在或数据无效`);
            return this.parseAlbumData(albumId, data);
        }

        async getPhotoDetail(photoId: string): Promise<Photo> {
            const resp = await this.reqApi(`${this.API_CHAPTER}?id=${photoId}`);
            const data = resp.resData;
            if (!data || !data.name) throw new Error(`章节 ${photoId} 不存在或数据无效`);
            return this.parsePhotoData(photoId, data);
        }

        async searchComics(params: SearchParams): Promise<SearchResult> {
            const { query, page = 1, order_by = 'view', time = 'all' } = params;
            const orderMap: { [key: string]: string } = { 'latest': 'mr', 'view': 'mv', 'picture': 'mp', 'like': 'tf' };
            const timeMap: { [key: string]: string } = { 'today': 't', 'week': 'w', 'month': 'm', 'all': 'a' };
            const apiParams = {
                search_query: query,
                page,
                o: orderMap[order_by.toLowerCase()] || orderMap['view'],
                t: timeMap[time.toLowerCase()] || timeMap['all']
            };
            const resp = await this.reqApi(`${this.API_SEARCH}?${this.toUrlSearchParams(apiParams)}`);
            const data = resp.resData;
            const results = (data.content || []).map((item: any): SearchResultItem => ({
                id: String(item.id || item.album_id),
                title: item.name || item.title
            }));
            return {
                search_params: params,
                results: results,
                total_results: results.length,
            };
        }

        async reqApi(url: string, method: 'GET' | 'POST' = 'GET', data?: any): Promise<JmApiResp> {
            const ts = Math.floor(Date.now() / 1000);
            for (let i = 0; i < this.domainList.length; i++) {
                const domain = this.domainList[i];
                for (let retry = 0; retry < this.retryTimes; retry++) {
                    try {
                        const fullUrl = `${JmModuleConfig.PROT}${domain}${url}`;
                        const [token, tokenparam] = JmCryptoTool.tokenAndTokenparam(ts);
                        const headers = { ...JmModuleConfig.APP_HEADERS_TEMPLATE, token, tokenparam };

                        const requestBuilder = this.client.newRequest().url(fullUrl).headers(headers);
                        if (method === 'POST') {
                            requestBuilder.method('POST').jsonBody(data);
                        }

                        const resp = await requestBuilder.build().execute();

                        if (resp.isSuccessful()) {
                            return new JmApiResp(resp, ts);
                        }
                    } catch (error: any) {
                        console.log(`[API] 请求失败: ${error.message} 域名: ${domain}`);
                        if (retry === this.retryTimes - 1 && i === this.domainList.length - 1) {
                            throw new Error(`所有域名和重试都失败: ${error.message}`);
                        }
                    }
                }
            }
            throw new Error('请求失败');
        }

        async downloadImage(imageUrl: string, savePath: string, scrambleId: number | string, photoId: string): Promise<boolean> {
            try {
                const response = await this.client.newRequest().url(imageUrl).headers(JmModuleConfig.APP_HEADERS_IMAGE).build().execute();

                if (!response.isSuccessful()) {
                    throw new Error(`HTTP error! status: ${response.statusCode}`);
                }
                const imageBase64 = response.bodyAsBase64();
                const dir = dirname(savePath);
                await ensureDirExists(dir);

                const imageName = JmImageTool.getFileNameFromUrl(imageUrl, false);
                const num = JmImageTool.getNum(scrambleId, photoId, imageName);
                await JmImageTool.decodeAndSave(num, imageBase64, savePath);

                return true;
            } catch (error: any) {
                console.error(`[图片] 下载失败: ${imageUrl}, 错误: ${error.message}`);
                return false;
            }
        }

        private toUrlSearchParams(obj: Record<string, any>): string {
            return Object.keys(obj).map(k => `${encodeURIComponent(k)}=${encodeURIComponent(obj[k])}`).join('&');
        }

        private parseAlbumData(albumId: string, data: any): Album {
            const episodeList = data.series && data.series.length > 0 ? data.series : [{ id: albumId, title: data.name }];
            return {
                id: albumId,
                title: data.name || `本子 ${albumId}`,
                author: (data.author && data.author[0]) || '未知作者',
                episodeList: episodeList,
                scrambleId: data.scramble_id || JmMagicConstants.SCRAMBLE_220980,
                length: episodeList.length,
            };
        }

        private parsePhotoData(photoId: string, data: any): Photo {
            return {
                id: photoId,
                title: data.name || `章节 ${photoId}`,
                pageArr: data.images || [],
                albumId: data.album_id || photoId,
                scrambleId: data.scramble_id || JmMagicConstants.SCRAMBLE_220980,
                length: (data.images || []).length,
            };
        }
    }

    class JmDownloaderImpl {
        public option: JmOptionImpl;
        public client: JmApiClientImpl;

        constructor(option: JmOptionImpl) {
            this.option = option;
            this.client = option.buildJmClient();
        }

        async downloadAlbum(albumId: string): Promise<Album> {
            const album = await this.client.getAlbumDetail(albumId);
            await this.downloadByAlbumDetail(album);
            return album;
        }

        private async downloadByAlbumDetail(album: Album): Promise<void> {
            const albumDir = this.option.dirRule.decideAlbumRootDir(album);
            await ensureDirExists(albumDir);
            console.log(`[专辑: ${album.title}] 发现 ${album.episodeList.length} 个章节, 开始下载...`);

            const chapterConcurrency = 5;
            const tasks = album.episodeList.map((episode, i) => async () => {
                console.log(`  [章节 ${i + 1}/${album.episodeList.length}] 开始下载: ${episode.title} (${episode.id})`);
                try {
                    const photo = await this.client.getPhotoDetail(episode.id);
                    await this.downloadPhotoImages(photo, albumDir, album.id);
                    console.log(`  [章节 ${i + 1}/${album.episodeList.length}] 下载完成: ${episode.title}`);
                } catch (e: any) {
                    console.error(`  [章节 ${i + 1}/${album.episodeList.length}] 下载失败: ${episode.title}, 错误: ${e.message}`);
                }
            });

            await runTasksWithConcurrency(tasks, chapterConcurrency);
        }

        private async downloadPhotoImages(photo: Photo, albumDir: string, albumId: string): Promise<void> {
            if (!photo.pageArr || photo.pageArr.length === 0) return;

            console.log(`    [图片集: ${photo.title}] 发现 ${photo.pageArr.length} 张图片, 开始下载...`);
            const concurrencyLimit = 10;

            const tasks = photo.pageArr.map((imageName, i) => {
                return async () => {
                    const finalFileName = `${(i + 1).toString().padStart(5, '0')}.jpg`;
                    const filePath = joinPath(albumDir, finalFileName);

                    const fileExists = await Tools.Files.exists(filePath);
                    if (fileExists.exists) {
                        return;
                    }

                    const imageUrl = this.buildImageUrl(photo, imageName);
                    try {
                        await this.client.downloadImage(imageUrl, filePath, photo.scrambleId, photo.id);
                    } catch (e: any) {
                        console.error(`      [图片下载失败] ${finalFileName} from ${photo.title}: ${e.message}`);
                    }
                };
            });

            await runTasksWithConcurrency(tasks, concurrencyLimit);
            console.log(`    [图片集: ${photo.title}] 所有图片下载任务已处理。`);
        }

        private getFileExtension(filename: string): string {
            const dotIndex = filename.lastIndexOf('.');
            return dotIndex > 0 ? filename.substring(dotIndex + 1) : 'jpg';
        }

        private buildImageUrl(photo: Photo, imageName: string): string {
            const domain = JmModuleConfig.DOMAIN_IMAGE_LIST[Math.floor(Math.random() * JmModuleConfig.DOMAIN_IMAGE_LIST.length)];
            return `${JmModuleConfig.PROT}${domain}/media/photos/${photo.albumId}/${imageName}`;
        }
    }

    class SimpleJMDownloader {
        private downloader: JmDownloaderImpl;
        private client: JmApiClientImpl;
        private option: JmOptionImpl;

        constructor(downloadDir: string = DEFAULT_DOWNLOAD_DIR) {
            this.option = JmOptionImpl.default(downloadDir);
            this.downloader = new JmDownloaderImpl(this.option);
            this.client = this.option.buildJmClient();
            console.log(`✅ JM下载器初始化成功, 下载目录: ${this.option.dirRule.baseDir}`);
        }

        async searchComics(params: SearchParams): Promise<SearchResult> {
            console.log(`🔍 搜索漫画: ${params.query}`);
            return await this.client.searchComics(params);
        }

        async getAlbumInfo(albumId: string): Promise<AlbumInfo> {
            const album = await this.client.getAlbumDetail(albumId);
            return {
                id: album.id,
                title: album.title,
                author: album.author,
                chapterCount: album.length,
                success: true
            };
        }

        async downloadAlbum(albumId: string): Promise<DownloadResult> {
            console.log(`📖 获取本子信息: ${albumId}`);
            try {
                const info = await this.getAlbumInfo(albumId);
                if (!info.success) return { success: false, albumId, error: "获取信息失败" };

                console.log(`📥 开始下载本子: ${info.title}`);
                await this.downloader.downloadAlbum(albumId);
                const downloadedFiles = await this._checkDownloadedFiles(info.title);

                return {
                    success: true,
                    albumId: albumId,
                    title: info.title,
                    downloadedFiles
                };
            } catch (error: any) {
                return { success: false, albumId, error: error.message };
            }
        }

        async batchDownload(albumIds: string[]): Promise<BatchDownloadResult[]> {
            const results: BatchDownloadResult[] = [];
            console.log(`📦 开始批量下载 ${albumIds.length} 个本子`);

            const concurrencyLimit = 3; // 限制并发下载的漫画数量

            const tasks = albumIds.map((albumId, i) => async (): Promise<BatchDownloadResult> => {
                console.log(`\n[${i + 1}/${albumIds.length}] 开始处理本子: ${albumId}`);
                const result = await this.downloadAlbum(albumId);
                if (result.success) {
                    console.log(`✅ [${i + 1}/${albumIds.length}] 下载成功: ${result.title}`);
                } else {
                    console.log(`❌ [${i + 1}/${albumIds.length}] 下载失败: ${albumId}, ${result.error || 'Unknown error'}`);
                }
                return result;
            });

            return await runTasksWithConcurrency(tasks, concurrencyLimit);
        }

        private async _checkDownloadedFiles(title: string): Promise<NonNullable<DownloadResult['downloadedFiles']>> {
            const albumDir = this.option.dirRule.decideAlbumRootDir({ title });
            const dirExists = await Tools.Files.exists(albumDir);
            if (dirExists.exists) {
                const listResult = await Tools.Files.list(albumDir);
                const files = listResult.entries.map(e => e.name);
                return {
                    directory: albumDir,
                    fileCount: files.length,
                    files: files.slice(0, 10)
                };
            }
            return { directory: undefined, fileCount: 0, files: [] };
        }
    }
    //endregion

    //region Tool Implementations
    async function main() {
        console.log("🚀 开始执行JMComic工具功能测试...");
        const downloader = new SimpleJMDownloader(TEST_DOWNLOAD_DIR);
        const testQuery = "原神";

        console.log(`1. 测试搜索功能，关键词: "${testQuery}"`);
        const searchResult = await downloader.searchComics({ query: testQuery });

        if (!searchResult || !searchResult.results || searchResult.results.length === 0) {
            throw new Error(`搜索测试失败: 未能找到关于 "${testQuery}" 的任何结果。`);
        }

        console.log(`✅ 搜索成功, 找到 ${searchResult.total_results} 个结果。`);
        const firstAlbum = searchResult.results[0];
        console.log(`2. 测试获取作品信息功能, 作品ID: ${firstAlbum.id} (${firstAlbum.title})`);

        const albumInfo = await downloader.getAlbumInfo(firstAlbum.id);

        if (!albumInfo || !albumInfo.success) {
            throw new Error(`获取作品信息失败, ID: ${firstAlbum.id}`);
        }

        console.log(`✅ 作品信息获取成功:`);
        console.log(`   - 标题: ${albumInfo.title}`);
        console.log(`   - 作者: ${albumInfo.author}`);
        console.log(`   - 章节数: ${albumInfo.chapterCount}`);

        console.log(`3. 测试下载功能, 作品ID: ${firstAlbum.id} (${firstAlbum.title})`);
        const downloadResult = await downloader.downloadAlbum(firstAlbum.id);

        if (!downloadResult || !downloadResult.success) {
            throw new Error(`下载作品失败, ID: ${firstAlbum.id}`);
        }

        console.log(`✅ 下载成功:`);
        console.log(`   - 保存目录: ${downloadResult.downloadedFiles!.directory}`);
        console.log(`   - 文件数量: ${downloadResult.downloadedFiles!.fileCount}`);

        const summary = `JMComic工具测试完成。成功搜索、获取信息并下载了作品《${albumInfo.title}》。`;
        console.log(`\n${summary}`);
        return summary;
    }

    async function search_comics(params: SearchParams) {
        const downloader = new SimpleJMDownloader();
        return await downloader.searchComics(params);
    }

    async function get_album_info(params: { album_id: string }) {
        const downloader = new SimpleJMDownloader();
        return await downloader.getAlbumInfo(params.album_id);
    }

    async function download_album(params: { album_id: string, download_dir?: string }) {
        const downloader = new SimpleJMDownloader(params.download_dir);
        return await downloader.downloadAlbum(params.album_id);
    }

    async function batch_download_albums(params: { album_ids: string, download_dir?: string }) {
        const albumIds = params.album_ids.split(',').map(id => id.trim()).filter(id => id);
        if (albumIds.length === 0) throw new Error("album_ids不能为空");
        const downloader = new SimpleJMDownloader(params.download_dir);
        return await downloader.batchDownload(albumIds);
    }

    async function jmcomic_wrap(func: Function, params: any, successMessage: string, failMessage: string) {
        try {
            console.log(`开始执行: ${func.name}`);
            const result = await func(params);
            complete({ success: true, message: successMessage, data: result });
        } catch (error: any) {
            console.error(`${func.name} 执行失败: ${error.message}`);
            complete({ success: false, message: `${failMessage}: ${error.message}`, error_stack: error.stack });
        }
    }
    //endregion

    return {
        main: (p: any) => jmcomic_wrap(main, p, '功能测试完成', '功能测试失败'),
        search_comics: (p: SearchParams) => jmcomic_wrap(search_comics, p, '搜索完成', '搜索失败'),
        get_album_info: (p: { album_id: string }) => jmcomic_wrap(get_album_info, p, '信息获取完成', '信息获取失败'),
        download_album: (p: { album_id: string, download_dir?: string }) => jmcomic_wrap(download_album, p, '下载完成', '下载失败'),
        batch_download_albums: (p: { album_ids: string, download_dir?: string }) => jmcomic_wrap(batch_download_albums, p, '批量下载完成', '批量下载失败'),
    };
})();

exports.main = jmcomic.main;
exports.search_comics = jmcomic.search_comics;
exports.get_album_info = jmcomic.get_album_info;
exports.download_album = jmcomic.download_album;
exports.batch_download_albums = jmcomic.batch_download_albums;