// ==UserScript==
// @name         tokiDownloader
// @namespace    https://github.com/crossSiteKikyo/tokiDownloader
// @version      0.0.4
// @description  북토끼, 뉴토끼, 마나토끼, 일일툰 다운로더
// @author       hehaho
// @match        https://*.com/webtoon/*
// @match        https://*.com/novel/*
// @match        https://*.net/comic/*
// @match        http://*.cprapid.com:*/bbs/board.php*
// @icon         https://github.com/user-attachments/assets/99f5bb36-4ef8-40cc-8ae5-e3bf1c7952ad
// @grant        GM_registerMenuCommand
// @grant        GM_xmlhttpRequest
// @require      https://cdnjs.cloudflare.com/ajax/libs/jszip/3.7.1/jszip.min.js
// @require      https://cdnjs.cloudflare.com/ajax/libs/jszip-utils/0.1.0/jszip-utils.js
// @run-at       document-end
// @license      MIT
// @downloadURL https://update.sleazyfork.org/scripts/531932/tokiDownloader.user.js
// @updateURL https://update.sleazyfork.org/scripts/531932/tokiDownloader.meta.js
// ==/UserScript==

(function () {
    'use strict';

    // 글로벌 이미지 URL 저장소 (네트워크 모니터링용)
    window.capturedImageUrls = [];
    
    // fetch 인터셉트 (모든 페이지에서 실행)
    const originalFetch = window.fetch;
    window.fetch = function(...args) {
        const url = typeof args[0] === 'string' ? args[0] : args[0]?.url;
        if (url && (url.includes('pl3040.com') || url.includes('www.pl3040.com')) && 
            (url.includes('.jpg') || url.includes('.png') || url.includes('.webp'))) {
            if (!window.capturedImageUrls.includes(url)) {
                window.capturedImageUrls.push(url);
            }
        }
        return originalFetch.apply(this, args);
    };

    // XMLHttpRequest 인터셉트
    const originalOpen = XMLHttpRequest.prototype.open;
    XMLHttpRequest.prototype.open = function(method, url, ...rest) {
        if (url && (url.includes('pl3040.com') || url.includes('www.pl3040.com')) && 
            (url.includes('.jpg') || url.includes('.png') || url.includes('.webp'))) {
            if (!window.capturedImageUrls.includes(url)) {
                window.capturedImageUrls.push(url);
            }
        }
        return originalOpen.apply(this, [method, url, ...rest]);
    };

    let site = '뉴토끼'; // 예시
    let protocolDomain = 'https://newtoki350.com'; // 예시
    // 현재 url 체크
    const currentURL = document.URL;
    if (currentURL.match(/^https:\/\/booktoki[0-9]+.com\/novel\/[0-9]+/)) {
        site = "북토끼"; protocolDomain = currentURL.match(/^https:\/\/booktoki[0-9]+.com/)[0];
    }
    else if (currentURL.match(/^https:\/\/newtoki[0-9]+.com\/webtoon\/[0-9]+/)) {
        site = "뉴토끼"; protocolDomain = currentURL.match(/^https:\/\/newtoki[0-9]+.com/)[0];
    }
    else if (currentURL.match(/^https:\/\/manatoki[0-9]+.net\/comic\/[0-9]+/)) {
        site = "마나토끼"; protocolDomain = currentURL.match(/^https:\/\/manatoki[0-9]+.net/)[0];
    }
    else if (currentURL.match(/\/bbs\/board\.php.*bo_table=toons.*wr_id=/)) {
        site = "일일툰"; protocolDomain = currentURL.match(/^https?:\/\/[^:]+/)[0];
    }
    else {
        // 다운 페이지가 아니라면 리턴. @match가 정규표현식이 아니기 때문에 정확한 host를 매치 할 수 없기 때문.
        return;
    }

    function sleep(ms) {
        return new Promise(resolve => {
            setTimeout(() => resolve(), ms);
        })
    }

    function extractComicMetadata() {
        let seriesName = '';
        let writerName = '';

        // 마나토끼, 뉴토끼에서 시리즈 이름과 작가 추출
        if (site === "마나토끼" || site === "뉴토끼") {
            // 시리즈 이름 추출 (페이지 타이틀에서)
            const pageTitle = document.querySelector('h1');
            if (pageTitle) {
                const titleText = pageTitle.innerText.trim();
                seriesName = titleText.split('>')[0].trim().replace(/\s*\([^)]*\)$/, '');
            }

            // 작가 추출 (작가 라벨 다음의 링크)
            const viewContents = document.querySelectorAll('.view-content');
            for (let elem of viewContents) {
                if (elem.innerText.includes('작가')) {
                    const writerLink = elem.querySelector('a');
                    if (writerLink) {
                        writerName = writerLink.innerText.trim();
                    }
                    break;
                }
            }
        }

        return { seriesName, writerName };
    }

    function generateComicInfo(title, series, writer, number, pageCount, imageCount = 0) {
        let pagesXml = '';
        if (imageCount > 0) {
            for (let i = 0; i < imageCount; i++) {
                pagesXml += `        <Page Image="${i}" Type="Story"/>\n`;
            }
        }
        
        const comicInfo = `<?xml version="1.0" encoding="utf-8"?>
<ComicInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <Title>${title}</Title>
    <Series>${series}</Series>
    <Number>${number}</Number>
    <Count>-1</Count>
    <Volume>-1</Volume>
    <Summary></Summary>
    <Notes></Notes>
    <Year>-1</Year>
    <Month>-1</Month>
    <Writer>${writer}</Writer>
    <Penciller></Penciller>
    <Inker></Inker>
    <Colorist></Colorist>
    <Letterer></Letterer>
    <CoverArtist></CoverArtist>
    <Editor></Editor>
    <Publisher></Publisher>
    <Imprint></Imprint>
    <Genre></Genre>
    <Web></Web>
    <PageCount>${pageCount}</PageCount>
    <LanguageISO>ko</LanguageISO>
    <Format></Format>
    <BlackAndWhite>Unknown</BlackAndWhite>
    <Manga>Yes</Manga>
${pagesXml ? `    <Pages>\n${pagesXml}    </Pages>\n` : ''}
</ComicInfo>`;
        return comicInfo;
    }

    async function tokiDownload(startIndex, lastIndex) {
        try {
            // 리스트들 가져오기
            let list = Array.from(document.querySelector('.list-body').querySelectorAll('li')).reverse();

            // 리스트 필터
            // startIndex가 있다면
            if (startIndex) {
                while (true) {
                    let num = parseInt(list[0].querySelector('.wr-num').innerText);
                    if (num < startIndex)
                        list.shift();
                    else
                        break;
                }
            }
            // lastIndex가 있다면
            if (lastIndex) {
                while (true) {
                    let num = parseInt(list.at(-1).querySelector('.wr-num').innerText);
                    if (lastIndex < num)
                        list.pop();
                    else
                        break;
                }
            }

            // iframe생성
            const iframe = document.createElement('iframe');
            iframe.width = 600;
            iframe.height = 600;
            document.querySelector('.content').prepend(iframe);
            const waitIframeLoad = (url) => {
                return new Promise((resolve) => {
                    iframe.addEventListener('load', () => resolve());
                    // iframe.addEventListener('DOMContentLoaded', () => resolve());
                    iframe.src = url;
                });
            };

            // 북토끼 - 현재 페이지의 리스트들을 다운한다.
            if (site == "북토끼") {

                const contentName = document.querySelector('.page-title .page-desc').innerText;

                for (let i = 0; i < list.length; i++) {
                    console.clear();
                    console.log(`${i + 1}/${list.length} 진행중`);

                    // 각 회차별로 개별 ZIP 생성
                    const zip = new JSZip();
                    
                    const num = list[i].querySelector('.wr-num').innerText.padStart(4, '0');
                    const fileName = list[i].querySelector('a').innerHTML.replace(/<span[\s\S]*?\/span>/g, '').trim();
                    const src = list[i].querySelector('a').href;
                    await waitIframeLoad(src);
                    await sleep(1000);
                    const iframeDocument = iframe.contentWindow.document;
                    // 소설 텍스트 추출
                    const fileContent = iframeDocument.querySelector('#novel_content').innerText;
                    // 텍스트 파일을 ZIP에 추가
                    zip.file(`${num} ${fileName}.txt`, fileContent);
                    
                    // comicinfo.xml 생성 및 추가
                    const comicInfoContent = generateComicInfo(fileName, '북토끼', '', num, 1);
                    zip.file('ComicInfo.xml', comicInfoContent);
                    
                    // ZIP 생성 및 다운로드
                    const content = await zip.generateAsync({ type: "blob" });
                    const link = document.createElement("a");
                    link.href = URL.createObjectURL(content);
                    link.download = `${num} ${fileName}`;
                    link.click();
                    URL.revokeObjectURL(link.href);
                    console.log(`${i + 1}/${list.length} ${fileName} 다운완료`);
                    
                    // 너무 급하게 다운받다 블록당하는거 방지 30초
                    await sleep(30000);
                }
            }
            // 뉴토끼 또는 마나토끼
            else if (site == "뉴토끼" || site == "마나토끼") {
                // 리스트 페이지에서 시리즈 이름과 작가 추출
                const metadata = extractComicMetadata();
                const seriesName = metadata.seriesName;
                const writerName = metadata.writerName;

                // 이미지를 fetch하고 zip에 추가하는 Promise (GM_xmlhttpRequest로 CORS 우회)
                const fetchAndAddToZip = (src, folderName, j, extension, listLen, zipObj) => {
                    return new Promise((resolve) => {
                        GM_xmlhttpRequest({
                            method: 'GET',
                            url: src,
                            responseType: 'arraybuffer',
                            headers: {
                                'Referer': protocolDomain,
                                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
                            },
                            onload: (response) => {
                                if (response.status === 200) {
                                    const blob = new Blob([response.response], { type: 'image/jpeg' });
                                    zipObj.file(`${folderName} image${j.toString().padStart(4, '0')}${extension}`, blob);
                                    console.log(`${j + 1}/${listLen}진행완료`);
                                } else {
                                    console.log(`이미지 다운로드 실패 (${response.status}): ${src}`);
                                }
                                resolve();
                            },
                            onerror: (error) => {
                                console.log(`이미지 다운로드 오류: ${src}`);
                                resolve();
                            },
                            ontimeout: (error) => {
                                console.log(`이미지 다운로드 타임아웃: ${src}`);
                                resolve();
                            }
                        });
                    })
                };
                for (let i = 0; i < list.length; i++) {
                    // 각 회차별로 개별 ZIP 생성
                    const zip = new JSZip();
                    
                    const num = list[i].querySelector('.wr-num').innerText.padStart(4, '0');
                    const folderName = list[i].querySelector('a').innerHTML.replace(/<span[\s\S]*?\/span>/g, '').trim();
                    const src = list[i].querySelector('a').href;
                    console.clear();
                    console.log(`${i + 1}/${list.length} ${folderName} 진행중`);

                    await waitIframeLoad(src);
                    await sleep(1000);
                    const iframeDocument = iframe.contentWindow.document;
                    // 이미지 추출
                    // view-padding의 div의 img.
                    let imgLists = Array.from(iframeDocument.querySelectorAll('.view-padding div img'));
                    console.log(`이미지 ${imgLists.length}개 감지`);
                    
                    // GIF 로딩 이미지가 실제 이미지로 변경될 때까지 대기하는 함수
                    const waitForImageToLoad = async (imgElement, timeoutMs = 8000) => {
                        const startTime = Date.now();
                        while (Date.now() - startTime < timeoutMs) {
                            let currentSrc = '';
                            
                            // 1. src 속성 확인
                            if (imgElement.src && !imgElement.src.includes('gif') && !imgElement.src.includes('loading')) {
                                currentSrc = imgElement.src;
                            }
                            
                            // 2. src가 gif/loading이면 data-* 속성 확인
                            if (!currentSrc) {
                                for (let attr of imgElement.attributes) {
                                    if (attr.name.startsWith('data-') && attr.value.includes('/')) {
                                        const value = attr.value.toLowerCase();
                                        if (!value.includes('gif') && !value.includes('loading')) {
                                            currentSrc = attr.value;
                                            break;
                                        }
                                    }
                                }
                            }
                            
                            if (currentSrc) {
                                return currentSrc;
                            }
                            
                            await sleep(100);
                        }
                        return '';
                    };

                    // 모든 이미지를 스크롤하여 실제 src가 로드되도록 강제
                    for (let j = 0; j < imgLists.length; j++) {
                        imgLists[j].scrollIntoView({ behavior: 'auto', block: 'center' });
                        await sleep(100);
                    }
                    let promiseList = [];
                    for (let j = 0; j < imgLists.length; j++) {
                        // data-l44925d0f9f="src"같이 속성을 부여해놓고 스크롤 해야 src가 바뀌는 방식이다.
                        // src를 직접 가져오면 loading.gif를 가져온다.
                        // protocolDomain으로 바꿈으로서 CORS 해결
                        let src = '';
                        try {
                            const imgElement = imgLists[j];
                            
                            // GIF가 아닌 실제 이미지가 로드될 때까지 대기 (최대 8초)
                            src = await waitForImageToLoad(imgElement);
                            
                            // 여전히 src를 못 찾았으면 outerHTML에서 추출 시도
                            if (!src) {
                                const htmlStr = imgElement.outerHTML;
                                const srcMatch = htmlStr.match(/src="([^"]+)"/);
                                if (srcMatch && !srcMatch[1].includes('gif') && !srcMatch[1].includes('loading')) {
                                    src = srcMatch[1];
                                } else {
                                    const dataMatch = htmlStr.match(/\/data[^"\s]+/);
                                    if (dataMatch && !dataMatch[0].includes('gif')) {
                                        src = dataMatch[0];
                                    }
                                }
                            }
                            
                            if (!src) {
                                console.log(`이미지 ${j}의 경로를 찾을 수 없음`);
                                continue;
                            }
                            
                            // src가 이미 절대 URL이면 그대로 사용, 상대경로면 protocolDomain 추가
                            if (!src.startsWith('http')) {
                                src = `${protocolDomain}${src}`;
                            }
                            
                            // 가끔 확장자가 없는 이미지가 있는데, 확장자가 없으면 기본값(.jpg) 사용
                            const extensionMatch = src.match(/\.[a-zA-Z0-9]+$/);
                            const extension = extensionMatch ? extensionMatch[0] : '.jpg';
                            promiseList.push(fetchAndAddToZip(src, folderName, j, extension, imgLists.length, zip));
                        } catch(error) {
                            console.log(`이미지 ${j} 처리 중 오류:`, error);
                        }
                    }
                    await Promise.all(promiseList);
                    
                    // comicinfo.xml 생성 및 추가 (시리즈명과 작가 정보 포함)
                    const comicInfoContent = generateComicInfo(folderName, seriesName, writerName, num, imgLists.length, imgLists.length);
                    zip.file('ComicInfo.xml', comicInfoContent);
                    
                    // ZIP 생성 및 다운로드
                    const content = await zip.generateAsync({ type: "blob" });
                    const link = document.createElement("a");
                    link.href = URL.createObjectURL(content);
                    link.download = `${num} ${folderName}`;
                    link.click();
                    URL.revokeObjectURL(link.href);
                    
                    console.log(`${i + 1}/${list.length} ${folderName} 완료`);

                    // 너무 급하게 다운받다 블록당하는거 방지 30초
                    await sleep(30000);
                }
            }
            // 일일툰
            else if (site === "일일툰") {
                // URL에서 시리즈 ID와 에피소드 ID 추출
                const urlParams = new URLSearchParams(window.location.search);
                const seriesId = urlParams.get('is') || '';
                const episodeId = urlParams.get('wr_id') || '';
                
                if (!seriesId || !episodeId) {
                    alert('시리즈 ID 또는 에피소드 ID를 찾을 수 없습니다.');
                    return;
                }

                // 제목 추출
                const titleElement = document.querySelector('h1');
                const title = titleElement ? titleElement.innerText.trim() : '제목없음';

                // 전역 변수에서 이미 캡처된 이미지 URL 가져오기
                let imageUrls = window.capturedImageUrls || [];

                console.clear();
                console.log(`일일툰 다운로드 시작`);
                console.log(`현재까지 감지된 이미지: ${imageUrls.length}개`);

                // 이미지가 없으면 추가 대기
                if (imageUrls.length === 0) {
                    console.log('이미지 로드 대기 중...');
                    for (let i = 0; i < 10; i++) {
                        await sleep(500);
                        imageUrls = window.capturedImageUrls || [];
                        console.log(`대기 ${i+1}: ${imageUrls.length}개`);
                        if (imageUrls.length > 0) break;
                    }
                }

                if (imageUrls.length === 0) {
                    alert('이미지 URL을 감지하지 못했습니다. 페이지가 완전히 로드되지 않았을 수 있습니다.');
                    return;
                }

                // ZIP 생성
                const zip = new JSZip();

                // 이미지 다운로드 함수
                const downloadImage = (url, index, total) => {
                    return new Promise((resolve) => {
                        GM_xmlhttpRequest({
                            method: 'GET',
                            url: url,
                            responseType: 'arraybuffer',
                            headers: {
                                'Referer': protocolDomain,
                                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
                            },
                            onload: (response) => {
                                if (response.status === 200) {
                                    const blob = new Blob([response.response], { type: 'image/jpeg' });
                                    const filename = `image${String(index).padStart(4, '0')}.jpg`;
                                    zip.file(filename, blob);
                                    console.log(`${index + 1}/${total} 다운로드 완료`);
                                } else {
                                    console.log(`이미지 ${index} 다운로드 실패 (${response.status})`);
                                }
                                resolve();
                            },
                            onerror: (error) => {
                                console.log(`이미지 ${index} 다운로드 오류:`, error);
                                resolve();
                            },
                            ontimeout: () => {
                                console.log(`이미지 ${index} 다운로드 타임아웃`);
                                resolve();
                            }
                        });
                    });
                };

                // 모든 이미지 다운로드
                let promiseList = [];
                for (let i = 0; i < imageUrls.length; i++) {
                    promiseList.push(downloadImage(imageUrls[i], i, imageUrls.length));
                    // 다운로드 간격 (과도한 요청 방지)
                    if (promiseList.length >= 5) {
                        await Promise.all(promiseList);
                        promiseList = [];
                        await sleep(1000);
                    }
                }
                
                // 남은 요청 처리
                if (promiseList.length > 0) {
                    await Promise.all(promiseList);
                }

                // comicinfo.xml 생성 및 추가
                const comicInfoContent = generateComicInfo(title, title, '', '1', imageUrls.length, imageUrls.length);
                zip.file('ComicInfo.xml', comicInfoContent);

                // ZIP 생성 및 다운로드
                const content = await zip.generateAsync({ type: "blob" });
                const link = document.createElement("a");
                link.href = URL.createObjectURL(content);
                link.download = title;
                link.click();
                URL.revokeObjectURL(link.href);

                console.log(`완료: ${imageUrls.length}개 이미지 다운로드`);
            }

            console.log(`모든 회차 다운완료`);
        } catch (error) {
            alert(`tokiDownload 오류발생: ${site}\n${currentURL}\n` + error);
            console.error(error);
        }
    }

    // ui 추가
    GM_registerMenuCommand('전체 다운로드', () => tokiDownload());
    GM_registerMenuCommand('N번째 회차부터', () => {
        const startPageInput = prompt('몇번째 회차부터 저장할까요?', 1);
        tokiDownload(startPageInput);
    });
    GM_registerMenuCommand('N번째 회차부터 N번째 까지', () => {
        const startPageInput = prompt('몇번째 회차부터 저장할까요?', 1);
        const endPageInput = prompt('몇번째 회차까지 저장할까요?', 2);
        tokiDownload(startPageInput, endPageInput);
    });
    // Your code here...
})();
