#!/usr/bin/env node
/**
 * MangaDex wrapper (ESM) — no API key
 * Flow: home/search → detail → chapters → read
 *
 *   node mangadex.js home
 *   node mangadex.js search "solo leveling"
 *   node mangadex.js detail <manga-id>
 *   node mangadex.js chapters <manga-id> --lang en
 *   node mangadex.js read <chapter-id>
 */

import axios from 'axios';
import { pathToFileURL } from 'url';
import path from 'path';
import process from 'process';

const API = 'https://api.mangadex.org';
const UP = 'https://uploads.mangadex.org';
const REPORT = 'https://api.mangadex.network/report';

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

function pick(obj, langs = ['en', 'ja-ro', 'ja', 'id']) {
  if (!obj || typeof obj !== 'object') return null;
  for (const l of langs) if (obj[l]) return obj[l];
  const k = Object.keys(obj);
  return k.length ? obj[k[0]] : null;
}

function flat(params = {}) {
  const out = {};
  for (const [k, v] of Object.entries(params)) {
    if (v == null) continue;
    if (Array.isArray(v)) out[`${k}[]`] = v;
    else if (typeof v === 'object') {
      for (const [sk, sv] of Object.entries(v))
        out[`${k}[${sk}]`] = sv;
    } else out[k] = v;
  }
  return out;
}

export class MangaDex {
  constructor({ timeout = 20000, rateMs = 220 } = {}) {
    this.rateMs = rateMs;
    this._last = 0;
    this.http = axios.create({
      baseURL: API,
      timeout,
      headers: {
        'User-Agent': 'MangaDex-Wrapper/3.1',
        Accept: 'application/json',
      },
    });
  }

  async req(method, url, { params, data } = {}) {
    const wait = this.rateMs - (Date.now() - this._last);
    if (wait > 0) await sleep(wait);
    this._last = Date.now();
    try {
      const res = await this.http.request({
        method,
        url,
        params: params ? flat(params) : undefined,
        data,
      });
      return res.data;
    } catch (err) {
      const status = err.response?.status;
      const msg =
        err.response?.data?.errors?.[0]?.detail ||
        err.response?.data?.message ||
        err.message;
      const e = new Error(`API ${status || '?'}: ${msg}`);
      e.status = status;
      throw e;
    }
  }

  // ── mappers ──────────────────────────────────────────────────────────────

  _manga(e) {
    if (!e) return null;
    const a = e.attributes || {};
    const rels = e.relationships || [];
    const cover = rels.find((r) => r.type === 'cover_art');
    const fn = cover?.attributes?.fileName;
    const authors = rels
      .filter((r) => r.type === 'author' || r.type === 'artist')
      .map((r) => r.attributes?.name)
      .filter(Boolean);

    return {
      id: e.id,
      title: pick(a.title),
      description: (pick(a.description) || '').slice(0, 300) || null,
      status: a.status,
      year: a.year,
      originalLanguage: a.originalLanguage,
      contentRating: a.contentRating,
      tags: (a.tags || [])
        .map((t) => pick(t.attributes?.name))
        .filter(Boolean)
        .slice(0, 12),
      authors: [...new Set(authors)],
      cover: fn ? `${UP}/covers/${e.id}/${fn}.256.jpg` : null,
      coverFull: fn ? `${UP}/covers/${e.id}/${fn}` : null,
      lastChapter: a.lastChapter,
      lastVolume: a.lastVolume,
    };
  }

  _chapter(e) {
    if (!e) return null;
    const a = e.attributes || {};
    const rels = e.relationships || [];
    const manga = rels.find((r) => r.type === 'manga');
    const groups = rels
      .filter((r) => r.type === 'scanlation_group')
      .map((r) => r.attributes?.name || r.id);

    return {
      id: e.id,
      chapter: a.chapter,
      volume: a.volume,
      title: a.title || null,
      lang: a.translatedLanguage,
      pages: a.pages,
      publishAt: a.publishAt,
      externalUrl: a.externalUrl || null,
      mangaId: manga?.id || null,
      mangaTitle: manga?.attributes?.title
        ? pick(manga.attributes.title)
        : null,
      groups,
    };
  }

  _list(data, mapFn) {
    return {
      data: (data.data || []).map(mapFn),
      total: data.total ?? 0,
      limit: data.limit ?? 0,
      offset: data.offset ?? 0,
    };
  }

  // ── public API ───────────────────────────────────────────────────────────

  async home({ limit = 12, lang = 'en' } = {}) {
    const [popular, latest, recent] = await Promise.all([
      this.popular({ limit }),
      this.latest({ limit, lang }),
      this.recent({ limit }),
    ]);
    return {
      popular: popular.data,
      latest: latest.data,
      recent: recent.data,
    };
  }

  async popular({ limit = 20, offset = 0 } = {}) {
    return this.search({
      limit,
      offset,
      order: { followedCount: 'desc' },
      hasAvailableChapters: true,
    });
  }

  async recent({ limit = 20, offset = 0 } = {}) {
    return this.search({
      limit,
      offset,
      order: { createdAt: 'desc' },
      hasAvailableChapters: true,
    });
  }

  async latest({ limit = 20, offset = 0, lang = 'en' } = {}) {
    const data = await this.req('GET', '/chapter', {
      params: {
        limit: Math.min(limit, 100),
        offset,
        translatedLanguage: [lang],
        order: { readableAt: 'desc' },
        includes: ['manga', 'scanlation_group'],
        contentRating: [
          'safe', 'suggestive', 'erotica', 'pornographic',
        ],
        includeFutureUpdates: '0',
      },
    });
    const list = this._list(data, (e) => this._chapter(e));
    // default: only chapters with pages
    list.data = list.data.filter((c) => c.pages > 0);
    return list;
  }

  async search({
    title,
    limit = 10,
    offset = 0,
    status,
    lang,
    order,
    hasAvailableChapters,
    contentRating = ['safe', 'suggestive', 'erotica'],
  } = {}) {
    const params = {
      limit: Math.min(limit, 100),
      offset,
      title,
      status: status ? [status] : undefined,
      availableTranslatedLanguage: lang ? [lang] : undefined,
      order,
      hasAvailableChapters,
      contentRating,
      includes: ['cover_art', 'author', 'artist'],
    };
    Object.keys(params).forEach(
      (k) => params[k] === undefined && delete params[k]
    );
    const data = await this.req('GET', '/manga', { params });
    return this._list(data, (e) => this._manga(e));
  }

  async detail(id) {
    const data = await this.req('GET', `/manga/${id}`, {
      params: {
        includes: ['cover_art', 'author', 'artist', 'tag'],
      },
    });
    return this._manga(data.data);
  }

  async random() {
    const data = await this.req('GET', '/manga/random', {
      params: {
        includes: ['cover_art', 'author', 'artist'],
      },
    });
    return this._manga(data.data);
  }

  /**
   * List chapters. Default: only pages > 0 (readable on MD).
   * Pass includeEmpty: true to keep pages=0 / external.
   */
  async chapters(
    mangaId,
    {
      limit = 100,
      offset = 0,
      lang = 'en',
      includeEmpty = false,
    } = {}
  ) {
    const data = await this.req('GET', `/manga/${mangaId}/feed`, {
      params: {
        limit: Math.min(limit, 100),
        offset,
        translatedLanguage: [lang],
        order: { volume: 'asc', chapter: 'asc' },
        includes: ['scanlation_group'],
        contentRating: [
          'safe', 'suggestive', 'erotica', 'pornographic',
        ],
        includeFutureUpdates: '0',
        includeEmptyPages: includeEmpty ? '1' : '0',
        includeExternalUrl: includeEmpty ? '1' : '0',
      },
    });
    const list = this._list(data, (e) => this._chapter(e));
    if (!includeEmpty) {
      list.data = list.data.filter(
        (c) => c.pages > 0 && !c.externalUrl
      );
    }
    return list;
  }

  async allChapters(
    mangaId,
    { lang = 'en', includeEmpty = false } = {}
  ) {
    const all = [];
    let offset = 0;
    let total = Infinity;
    while (offset < total) {
      const page = await this.chapters(mangaId, {
        limit: 100,
        offset,
        lang,
        includeEmpty,
      });
      all.push(...page.data);
      total = page.total;
      offset += 100;
      if (!page.data.length && offset >= total) break;
      // when filtering, total is pre-filter; stop if empty page
      if (!page.data.length && !includeEmpty) {
        // keep paging until API exhausted
        if (offset >= total) break;
        continue;
      }
      if (!page.data.length) break;
    }
    return all;
  }

  async chapter(id) {
    const data = await this.req('GET', `/chapter/${id}`, {
      params: {
        includes: ['manga', 'scanlation_group'],
      },
    });
    return this._chapter(data.data);
  }

  /**
   * Get page image URLs with auto-retry on bad MD@Home node.
   * quality: 'data' | 'data-saver'
   * retries: how many times to re-fetch at-home server
   */
  async read(chapterId, quality = 'data', { retries = 3 } = {}) {
    const q = quality === 'data-saver' ? 'data-saver' : 'data';
    let lastErr = null;

    for (let attempt = 0; attempt <= retries; attempt++) {
      if (attempt > 0) await sleep(400 * attempt);

      const data = await this.req(
        'GET',
        `/at-home/server/${chapterId}`
      );
      const { baseUrl, chapter } = data;
      if (!chapter?.hash) {
        throw new Error('No page data (external/empty chapter?)');
      }

      const files =
        q === 'data-saver' ? chapter.dataSaver : chapter.data;
      if (!files?.length) {
        throw new Error('No page files (pages=0 or external)');
      }

      const urls = files.map(
        (f) => `${baseUrl}/${q}/${chapter.hash}/${f}`
      );

      // probe first page
      const ok = await this._probe(urls[0]);
      if (ok) {
        return {
          chapterId,
          quality: q,
          count: urls.length,
          urls,
        };
      }

      // report failure so MD can avoid this node
      this._report(urls[0], false).catch(() => {});
      lastErr = new Error(
        `MD@Home node failed (attempt ${attempt + 1}/${retries + 1})`
      );
    }

    throw lastErr || new Error('Failed to get readable pages');
  }

  /** HEAD/GET probe — true if image reachable */
  async _probe(url) {
    try {
      const res = await axios.head(url, {
        timeout: 8000,
        validateStatus: (s) => s >= 200 && s < 400,
        headers: {
          'User-Agent': 'MangaDex-Wrapper/3.1',
          Referer: 'https://mangadex.org/',
        },
      });
      return res.status >= 200 && res.status < 400;
    } catch {
      // some nodes reject HEAD — try range GET
      try {
        const res = await axios.get(url, {
          timeout: 10000,
          responseType: 'stream',
          headers: {
            'User-Agent': 'MangaDex-Wrapper/3.1',
            Referer: 'https://mangadex.org/',
            Range: 'bytes=0-0',
          },
          validateStatus: (s) => s >= 200 && s < 400,
        });
        res.data.destroy?.();
        return true;
      } catch {
        return false;
      }
    }
  }

  async _report(url, success) {
    try {
      await axios.post(
        REPORT,
        {
          url,
          success,
          bytes: 0,
          duration: 0,
          cached: false,
        },
        {
          headers: { 'Content-Type': 'application/json' },
          timeout: 5000,
        }
      );
    } catch {
      // ignore
    }
  }

  async covers(mangaId, { limit = 20 } = {}) {
    const data = await this.req('GET', '/cover', {
      params: {
        manga: [mangaId],
        limit: Math.min(limit, 100),
        order: { volume: 'asc' },
      },
    });
    return (data.data || []).map((e) => {
      const a = e.attributes || {};
      return {
        id: e.id,
        volume: a.volume,
        fileName: a.fileName,
        url: `${UP}/covers/${mangaId}/${a.fileName}`,
        url256: `${UP}/covers/${mangaId}/${a.fileName}.256.jpg`,
      };
    });
  }

  async tags() {
    const data = await this.req('GET', '/manga/tag');
    return (data.data || []).map((t) => ({
      id: t.id,
      name: pick(t.attributes?.name),
      group: t.attributes?.group,
    }));
  }

  async stats(mangaId) {
    const data = await this.req('GET', '/statistics/manga', {
      params: { manga: [mangaId] },
    });
    const s = data.statistics?.[mangaId];
    if (!s) return null;
    return {
      follows: s.follows,
      rating: s.rating?.average ?? null,
      bayesian: s.rating?.bayesian ?? null,
      comments: s.comments?.repliesCount ?? 0,
    };
  }
}

export default MangaDex;

// ── CLI ────────────────────────────────────────────────────────────────────

const isMain =
  process.argv[1] &&
  pathToFileURL(path.resolve(process.argv[1])).href ===
    import.meta.url;

if (isMain) {
  const args = process.argv.slice(2);

  const flag = (n, d = null) => {
    const i = args.indexOf(`--${n}`);
    if (i === -1) return d;
    const v = args[i + 1];
    return !v || v.startsWith('--') ? d : v;
  };
  const has = (n) => args.includes(`--${n}`);

  const help = {
    usage: 'node mangadex.js <cmd> [args] [opts]',
    flow: 'home/search → detail → chapters → read',
    commands: {
      home: 'popular + latest + recent',
      search: 'search "title"',
      detail: 'manga detail by id',
      popular: 'popular manga',
      recent: 'recently added',
      latest: 'latest chapters (pages>0)',
      chapters: 'chapters of manga (pages>0)',
      allchapters: 'all chapters',
      chapter: 'one chapter meta',
      read: 'page image URLs (auto-retry)',
      covers: 'cover list',
      tags: 'all tags',
      stats: 'follows & rating',
      random: 'random manga',
    },
    options: {
      '--limit': 'default 12-20',
      '--offset': 'default 0',
      '--lang': 'en | id | ja ...',
      '--quality': 'data | data-saver',
      '--empty': 'include pages=0 / external',
      '--pretty': 'pretty json',
    },
  };

  const out = (data) => {
    console.log(
      has('pretty')
        ? JSON.stringify(data, null, 2)
        : JSON.stringify(data)
    );
  };

  async function main() {
    if (!args.length || has('help') || args[0] === 'help') {
      out(help);
      return;
    }

    const md = new MangaDex();
    const cmd = args[0];
    const limit = parseInt(flag('limit', '20'), 10);
    const offset = parseInt(flag('offset', '0'), 10);
    const lang = flag('lang', 'en');
    const quality = flag('quality', 'data');
    const includeEmpty = has('empty');

    let r;
    try {
      switch (cmd) {
        case 'home':
          r = await md.home({ limit, lang });
          break;
        case 'popular':
          r = await md.popular({ limit, offset });
          break;
        case 'recent':
          r = await md.recent({ limit, offset });
          break;
        case 'latest':
          r = await md.latest({ limit, offset, lang });
          break;
        case 'search': {
          const q = args[1];
          if (!q) throw new Error('need query');
          r = await md.search({ title: q, limit, offset, lang });
          break;
        }
        case 'detail':
        case 'manga': {
          const id = args[1];
          if (!id) throw new Error('need manga id');
          r = await md.detail(id);
          break;
        }
        case 'random':
          r = await md.random();
          break;
        case 'chapters': {
          const id = args[1];
          if (!id) throw new Error('need manga id');
          r = await md.chapters(id, {
            limit,
            offset,
            lang,
            includeEmpty,
          });
          break;
        }
        case 'allchapters': {
          const id = args[1];
          if (!id) throw new Error('need manga id');
          r = await md.allChapters(id, { lang, includeEmpty });
          break;
        }
        case 'chapter': {
          const id = args[1];
          if (!id) throw new Error('need chapter id');
          r = await md.chapter(id);
          break;
        }
        case 'read':
        case 'pages': {
          const id = args[1];
          if (!id) throw new Error('need chapter id');
          r = await md.read(id, quality);
          break;
        }
        case 'covers':
        case 'cover': {
          const id = args[1];
          if (!id) throw new Error('need manga id');
          r = await md.covers(id, { limit });
          break;
        }
        case 'tags':
          r = await md.tags();
          break;
        case 'stats': {
          const id = args[1];
          if (!id) throw new Error('need manga id');
          r = await md.stats(id);
          break;
        }
        default:
          throw new Error(`unknown: ${cmd}`);
      }
      out(r);
    } catch (err) {
      out({
        error: true,
        message: err.message,
        status: err.status || null,
      });
      process.exit(1);
    }
  }

  main();
}