import { fetchApi } from '@libs/fetch';
import { Plugin } from '@/types/plugin';
import { Filters, FilterTypes } from '@libs/filterInputs';
import { load as loadCheerio } from 'cheerio';
import { defaultCover } from '@libs/defaultCover';
import { NovelStatus } from '@libs/novelStatus';

// NovelDex is a Next.js application using app router, rsc ( react server components ), and flight protocol

type SeriesUrlFilters = {
  sort?: { value?: string };
  genre?: { value?: { include?: string[]; exclude?: string[] } };
  tag?: { value?: { include?: string[]; exclude?: string[] } };
  type?: { value?: string[] };
  status?: { value?: string[] };
  origin?: { value?: string[] };
  sale?: { value?: boolean };
  images?: { value?: boolean };
  ch_min?: { value?: string };
  ch_max?: { value?: string };
};

// Dealing with content encryption from noveldex
const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

function base64ToBytes(b64: string): Uint8Array {
  const clean = b64.replace(/[^A-Za-z0-9+/]/g, '');
  const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
  let o = 0;
  for (let i = 0; i < clean.length; i += 4) {
    const a = B64.indexOf(clean[i]);
    const b = B64.indexOf(clean[i + 1]);
    const c = i + 2 < clean.length ? B64.indexOf(clean[i + 2]) : -1;
    const d = i + 3 < clean.length ? B64.indexOf(clean[i + 3]) : -1;
    out[o++] = (a << 2) | (b >> 4);
    if (c >= 0) out[o++] = ((b & 15) << 4) | (c >> 2);
    if (d >= 0) out[o++] = ((c & 3) << 6) | d;
  }
  return out.subarray(0, o);
}

function deriveNoveldexKey(
  hint: string,
  timestamp: number,
  nonce: string,
): Uint8Array {
  const material = `${hint}|${timestamp}|${nonce}`;
  const key = new Uint8Array(32);
  let i = 0x811c9dc5;
  for (let j = 0; j < material.length; j++) {
    i ^= material.charCodeAt(j);
    i = Math.imul(i, 0x1000193) >>> 0;
  }
  for (let k = 0; k < 32; k++) {
    i ^= Math.imul(k, 0x9e3779b9) >>> 0;
    i = Math.imul(i, 0x1000193) >>> 0;
    key[k] = i & 0xff;
  }
  return key;
}

function xorDecrypt(cipher: Uint8Array, key: Uint8Array): Uint8Array {
  const out = new Uint8Array(cipher.length);
  for (let i = 0; i < cipher.length; i++) {
    out[i] = cipher[i] ^ key[i % key.length];
  }
  return out;
}

type NoveldexChapter = {
  title: string;
  number: number;
  publishedAt: string;
  hasAccess?: boolean;
};

type NoveldexGenre = {
  name: string;
};

type NoveldexSeriesData = {
  title: string;
  description?: string;
  coverImage?: string;
  status: string;
  chapterCount?: number; // HTML fallback only, for totalPages
  genres: NoveldexGenre[];
};

type NoveldexSeriesPage = {
  series: NoveldexSeriesData;
  chapters: NoveldexChapter[];
  totalPages: number;
};

type BrowseSeriesItem = {
  title: string;
  urlSlug: string;
  coverImage?: string;
};

type SeriesBrowsePage = {
  initialSeries: BrowseSeriesItem[];
};

type NovelStatusValue = (typeof NovelStatus)[keyof typeof NovelStatus];

class Noveldex implements Plugin.PluginBase {
  id = 'noveldex';
  name = 'NovelDex';
  icon = 'src/en/noveldex/icon.png';
  site = 'https://noveldex.io';
  version = '1.0.0';
  // Filter do take a lot of space
  filters = {
    sort: {
      label: 'Sort By',
      type: FilterTypes.Picker,
      value: 'views',
      options: [
        { label: 'Recently Updated', value: 'updated' },
        { label: 'Most Bookmarked', value: 'popular' },
        { label: 'Most Viewed', value: 'views' },
        { label: 'Longest', value: 'longest' },
        { label: 'Trending', value: 'trending' },
        { label: 'Rating', value: 'rating' },
        { label: 'Newest', value: 'newest' },
      ],
    },
    type: {
      label: 'Type',
      type: FilterTypes.CheckboxGroup,
      value: [],
      options: [
        { label: 'Novel', value: 'Novel' },
        { label: 'Light Novel', value: 'Light Novel' },
        { label: 'Web Novel', value: 'Web Novel' },
        { label: 'Published Novel', value: 'Published Novel' },
        { label: 'Fanfiction', value: 'Fanfiction' },
        { label: 'Original Fiction', value: 'Original Fiction' },
        { label: 'One Shot', value: 'One Shot' },
        { label: 'Manhwa', value: 'Manhwa' },
        { label: 'Manhua', value: 'Manhua' },
        { label: 'Manga', value: 'Manga' },
        { label: 'Webtoon', value: 'Webtoon' },
      ],
    },
    status: {
      label: 'Status',
      type: FilterTypes.CheckboxGroup,
      value: [],
      options: [
        { label: 'Ongoing', value: 'Ongoing' },
        { label: 'Completed', value: 'Completed' },
        { label: 'Hiatus', value: 'Hiatus' },
        { label: 'Dropped', value: 'Dropped' },
        { label: 'Discontinued', value: 'Discontinued' },
        { label: 'Upcoming', value: 'Upcoming' },
      ],
    },
    origin: {
      label: 'Origin',
      type: FilterTypes.CheckboxGroup,
      value: [],
      options: [
        { label: 'Korean', value: 'KOREAN' },
        { label: 'Japanese', value: 'JAPANESE' },
        { label: 'Chinese', value: 'CHINESE' },
        { label: 'Other', value: 'OTHER' },
      ],
    },
    sale: {
      label: 'On Sale',
      type: FilterTypes.Switch,
      value: false,
    },
    images: {
      label: 'Illustrated',
      type: FilterTypes.Switch,
      value: false,
    },
    ch_min: {
      label: 'Min Chapters',
      type: FilterTypes.TextInput,
      value: '',
    },
    ch_max: {
      label: 'Max Chapters',
      type: FilterTypes.TextInput,
      value: '',
    },
    genre: {
      label: 'Genres',
      type: FilterTypes.ExcludableCheckboxGroup,
      value: { include: [], exclude: [] },
      options: [
        { label: 'Action', value: 'action' },
        { label: 'Adult', value: 'adult' },
        { label: 'Adventure', value: 'adventure' },
        { label: 'Comedy', value: 'comedy' },
        { label: 'Drama', value: 'drama' },
        { label: 'Ecchi', value: 'ecchi' },
        { label: 'Fantasy', value: 'fantasy' },
        { label: 'GameLit', value: 'gamelit' },
        { label: 'Gender Bender', value: 'gender-bender' },
        { label: 'Harem', value: 'harem' },
        { label: 'Historical', value: 'historical' },
        { label: 'Horror', value: 'horror' },
        { label: 'Isekai', value: 'isekai' },
        { label: 'Josei', value: 'josei' },
        { label: 'LitRPG', value: 'litrpg' },
        { label: 'Martial Arts', value: 'martial-arts' },
        { label: 'Mature', value: 'mature' },
        { label: 'Mecha', value: 'mecha' },
        { label: 'Military', value: 'military' },
        { label: 'Mystery', value: 'mystery' },
        { label: 'Psychological', value: 'psychological' },
        { label: 'Romance', value: 'romance' },
        { label: 'School Life', value: 'school-life' },
        { label: 'Sci-Fi', value: 'sci-fi' },
        { label: 'Seinen', value: 'seinen' },
        { label: 'Shoujo', value: 'shoujo' },
        { label: 'Shoujo Ai', value: 'shoujo-ai' },
        { label: 'Shounen', value: 'shounen' },
        { label: 'Shounen Ai', value: 'shounen-ai' },
        { label: 'Slice of Life', value: 'slice-of-life' },
        { label: 'Smut', value: 'smut' },
        { label: 'Sports', value: 'sports' },
        { label: 'Supernatural', value: 'supernatural' },
        { label: 'Thriller', value: 'thriller' },
        { label: 'Tragedy', value: 'tragedy' },
        { label: 'Virtual Reality', value: 'virtual-reality' },
        { label: 'Wuxia', value: 'wuxia' },
        { label: 'Xianxia', value: 'xianxia' },
        { label: 'Xuanhuan', value: 'xuanhuan' },
        { label: 'Yaoi', value: 'yaoi' },
        { label: 'Yuri', value: 'yuri' },
      ],
    },
    tag: {
      label: 'Tags',
      type: FilterTypes.ExcludableCheckboxGroup,
      value: { include: [], exclude: [] },
      options: [
        { label: 'Male Protagonist', value: 'male-protagonist' },
        { label: 'Overpowered Protagonist', value: 'overpowered-protagonist' },
        { label: 'Modern Day', value: 'modern-day' },
        { label: 'Harem', value: 'harem' },
        { label: 'Misunderstandings', value: 'misunderstandings' },
        { label: 'Fantasy', value: 'fantasy' },
        { label: 'Academy', value: 'academy' },
        { label: 'Transmigration', value: 'transmigration' },
        { label: 'Fantasy World', value: 'fantasy-world' },
        { label: 'Magic', value: 'magic' },
        { label: 'Character Growth', value: 'character-growth' },
        { label: 'Obsessive Love', value: 'obsessive-love' },
        { label: 'Beautiful Female Lead', value: 'beautiful-female-lead' },
        { label: 'Modern Fantasy', value: 'modern-fantasy' },
        { label: 'Reincarnation', value: 'reincarnation' },
        { label: 'Game Elements', value: 'game-elements' },
        { label: 'Female Protagonist', value: 'female-protagonist' },
        { label: 'Action', value: 'action' },
        { label: 'Romance', value: 'romance' },
        { label: 'Survival', value: 'survival' },
        { label: 'Monsters', value: 'monsters' },
        { label: 'Possession', value: 'possession' },
        { label: 'Weak to Strong', value: 'weak-to-strong' },
        { label: 'R-18', value: 'r-18' },
        { label: 'Yandere', value: 'yandere' },
        { label: 'Adventure', value: 'adventure' },
        { label: '19+', value: '19-360615' },
        { label: 'Hunters', value: 'hunters' },
        { label: 'Special Abilities', value: 'special-abilities' },
        { label: 'Adult', value: 'adult' },
        { label: 'Dark Fantasy', value: 'dark-fantasy' },
        { label: 'Genius Protagonist', value: 'genius-protagonist' },
        { label: 'Calm Protagonist', value: 'calm-protagonist' },
        { label: 'Nobles', value: 'nobles' },
        { label: 'Gender Bender', value: 'gender-bender' },
        { label: 'System', value: 'system' },
        { label: 'Comedy', value: 'comedy' },
        { label: 'Light Novel', value: 'light-novel' },
        { label: 'Obsession', value: 'obsession' },
        { label: 'Dungeons', value: 'dungeons' },
        { label: 'Slice of Life', value: 'slice-of-life' },
        { label: 'Clever Protagonist', value: 'clever-protagonist' },
        { label: 'Drama', value: 'drama' },
        { label: 'Sword And Magic', value: 'sword-and-magic' },
        { label: 'Handsome Male Lead', value: 'handsome-male-lead' },
        { label: 'Aristocracy', value: 'aristocracy' },
        { label: 'Revenge', value: 'revenge' },
        { label: 'Male to Female', value: 'male-to-female' },
        { label: 'Adventurers', value: 'adventurers' },
        { label: 'Corruption', value: 'corruption' },
        { label: 'Second Chance', value: 'second-chance' },
        { label: 'Demons', value: 'demons' },
        { label: 'Mature', value: 'mature' },
        { label: 'Smut', value: 'smut' },
        { label: 'Pure Love', value: 'pure-love-978330' },
        { label: 'Regression', value: 'regression' },
        { label: 'Medieval', value: 'medieval' },
        { label: 'Politics', value: 'politics' },
        { label: 'Alternate World', value: 'alternate-world' },
        { label: 'Apocalypse', value: 'apocalypse' },
        { label: 'Accelerated Growth', value: 'accelerated-growth' },
        {
          label: 'Protagonist Strong from the Start',
          value: 'protagonist-strong-from-the-start',
        },
        { label: 'Martial Arts', value: 'martial-arts' },
        { label: 'Antihero Protagonist', value: 'antihero-protagonist' },
        { label: 'Heroes', value: 'heroes' },
        { label: 'Adapted to Manhwa', value: 'adapted-to-manhwa' },
        {
          label: 'Hard-Working Protagonist',
          value: 'hard-working-protagonist',
        },
        { label: 'Training', value: 'training' },
        { label: 'Ecchi', value: 'ecchi' },
        { label: 'Isekai', value: 'isekai' },
        { label: 'Royalty', value: 'royalty' },
        { label: 'Sword Wielder', value: 'sword-wielder' },
        { label: 'Urban Fantasy', value: 'urban-fantasy' },
        { label: 'Strong to Stronger', value: 'strong-to-stronger' },
        { label: 'Acting', value: 'acting' },
        { label: 'Regret', value: 'regret-728982' },
        { label: 'Supernatural', value: 'supernatural' },
        { label: 'Dark', value: 'dark' },
        { label: 'Betrayal', value: 'betrayal' },
        { label: 'Fantasy Creatures', value: 'fantasy-creatures' },
        { label: 'European Ambience', value: 'european-ambience' },
        {
          label: 'Schemes And Conspiracies',
          value: 'schemes-and-conspiracies',
        },
        { label: 'Level System', value: 'level-system' },
        { label: 'High Level', value: 'highlevel-008161' },
        { label: 'Romance Fantasy', value: 'romance-fantasy-578698' },
        { label: 'Live Streaming', value: 'livestreaming' },
        { label: 'Cunning Protagonist', value: 'cunning-protagonist' },
        { label: 'Gods', value: 'gods' },
        { label: 'Tragic Past', value: 'tragic-past' },
        { label: 'Incest', value: 'incest' },
        {
          label: 'Reincarnated in Another World',
          value: 'reincarnated-in-another-world',
        },
        { label: 'Hidden Identity', value: 'hidden-identity' },
        { label: 'Multiple POV', value: 'multiple-pov' },
        { label: 'First-time Intercourse', value: 'first-time-intercourse' },
        { label: 'Possessive Characters', value: 'possessive-characters' },
        {
          label: 'Transported into a Game World',
          value: 'transported-into-a-game-world',
        },
        { label: 'Hyundai', value: 'hyundai-025236' },
        { label: 'Kingdom Building', value: 'kingdom-building' },
        { label: 'Secret Identity', value: 'secret-identity' },
        { label: 'Tower Climbing', value: 'tower-climbing' },
        { label: 'Kingdoms', value: 'kingdoms' },
        { label: 'Military', value: 'military' },
        { label: 'Guilds', value: 'guilds' },
        { label: 'Netori', value: 'netori' },
        { label: 'Past Plays a Big Role', value: 'past-plays-a-big-role' },
        { label: 'Childhood Friends', value: 'childhood-friends' },
        { label: 'Ruthless Protagonist', value: 'ruthless-protagonist' },
        { label: 'Modern Knowledge', value: 'modern-knowledge' },
        { label: 'School Life', value: 'school-life' },
        { label: 'Hunter', value: 'hunter-343706' },
        { label: 'Slow Romance', value: 'slow-romance' },
        { label: 'Depictions of Cruelty', value: 'depictions-of-cruelty' },
        { label: 'Hidden Abilities', value: 'hidden-abilities' },
        { label: 'Strategist', value: 'strategist' },
        { label: 'Elves', value: 'elves' },
        { label: 'Modern', value: 'modern-943487' },
        { label: 'Hidden Power', value: 'hidden-power' },
        { label: 'Knights', value: 'knights' },
        { label: 'BDSM', value: 'bdsm' },
        { label: 'Determined Protagonist', value: 'determined-protagonist' },
      ],
    },
  } satisfies Filters;

  imageRequestInit?: Plugin.ImageRequestInit | undefined = undefined;
  webStorageUtilized?: boolean;

  private headers = {
    'User-Agent': `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36`,
  };

  // little fetchers helpers
  /*
        RSC response looks like this (simplified)

        1:I[99630,[],"LoadingBoundaryProvider"]
        5c:I[46538,[...chunks...],"SeriesBrowseGrid"]
        59:["$","$L5c",null,{"seed":"...","initialSeries":[...],...}]
    */

  private async fetchPage(url: string) {
    const repsonse = await fetchApi(url, {
      headers: this.headers,
    });
    return loadCheerio(await repsonse.text());
  }

  private async fetchRsc(url: string): Promise<string> {
    const res = await fetchApi(url, {
      headers: {
        'User-Agent': this.headers['User-Agent'],
        Referer: this.site,
        RSC: '1',
      },
    });
    return res.text();
  }

  // -----------------------------------------------------------------------
  // RSC parsing
  // -----------------------------------------------------------------------

  /**
        Find the flight-stream module id
        The id changes with each build, so we resolve it dynamically.
    */

  // For searching novels | Helpers for main function
  private findClientId(rscText: string, componentName: string): string | null {
    const escaped = componentName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    const match = rscText.match(
      new RegExp(`^([0-9a-fA-F]+):I\\[\\d+,\\[[^\\]]*\\],"${escaped}"\\]`, 'm'),
    );
    return match ? match[1] : null;
  }

  private findSeriesClientId(rscText: string): string | null {
    return this.findClientId(rscText, 'SeriesDetailClient');
  }

  /**
   * Return the substring of `text` starting at `start` (which must be `{` or
   * `[`) up to and including the matching closing bracket.
   * Handles nested braces, string literals, and escapes.
   */
  private extractBalancedJson(text: string, start: number): string | null {
    const first = text[start];
    if (first !== '{' && first !== '[') return null;

    const open = first;
    const close = open === '{' ? '}' : ']';
    let depth = 0;
    let inString = false;
    let escaped = false;

    for (let i = start; i < text.length; i++) {
      const c = text[i];
      if (escaped) {
        escaped = false;
        continue;
      }
      if (c === '\\') {
        escaped = true;
        continue;
      }
      if (c === '"') {
        inString = !inString;
        continue;
      }
      if (inString) continue;

      if (c === open) depth++;
      else if (c === close) {
        depth--;
        if (depth === 0) return text.slice(start, i + 1);
      }
    }
    return null;
  }

  // Pull `{ series, chapters, totalPages, ... }` out of the flight payload.
  private extractSeriesPage(rscText: string): NoveldexSeriesPage | null {
    const clientId = this.findSeriesClientId(rscText);
    if (!clientId) return null;

    const marker = `"$L${clientId}",null,`;

    let idx = rscText.indexOf(marker);
    while (idx !== -1) {
      const jsonText = this.extractBalancedJson(rscText, idx + marker.length);
      if (jsonText) {
        try {
          const parsed = JSON.parse(jsonText);
          if (parsed && parsed.series && Array.isArray(parsed.chapters)) {
            return parsed as NoveldexSeriesPage;
          }
        } catch {
          // fall through and try the next occurrence
        }
      }
      idx = rscText.indexOf(marker, idx + marker.length);
    }

    return null;
  }

  //Fetch one page of a series via RSC
  private async fetchSeriesPage(
    novelPath: string,
    page: number,
  ): Promise<NoveldexSeriesPage | null> {
    const base = novelPath.split('?')[0]; // Modify the path lil bit
    const url = `${this.site}${base}?page=${page}`;
    const rscText = await this.fetchRsc(url);
    return this.extractSeriesPage(rscText);
  }

  // Function to continue fetching the remaining chapters through RSC raw flight text
  private mapChapters(
    chapters: NoveldexChapter[],
    base: string,
  ): Plugin.ChapterItem[] {
    return chapters.map(chapter => {
      const accessible = chapter.hasAccess !== false;
      const title = chapter.title || 'Untitled';
      return {
        name: accessible ? title : `🔒 ${title}`,
        path: `${base}/chapter/${chapter.number}`,
        releaseTime: chapter.publishedAt,
        chapterNumber: chapter.number,
      };
    });
  }

  // Convert NovelDex's raw status strings into the framework's NovelStatus enum.
  private mapStatus(raw: string | undefined): NovelStatusValue {
    switch (raw?.toUpperCase()) {
      case 'ONGOING':
        return NovelStatus.Ongoing;
      case 'COMPLETED':
        return NovelStatus.Completed;
      case 'HIATUS':
        return NovelStatus.OnHiatus;
      case 'DROPPED':
      case 'DISCONTINUED':
      case 'CANCELLED':
      case 'CANCELED':
        return NovelStatus.Cancelled;
      case 'UPCOMING':
      case 'INACTIVE':
        return NovelStatus.Inactive;
      case 'LICENSED':
        return NovelStatus.Licensed;
      default:
        return NovelStatus.Unknown;
    }
  }

  // Popular list or Latest Novel
  async popularNovels(
    page: number,
    {
      showLatestNovels,
      filters,
    }: Plugin.PopularNovelsOptions<typeof this.filters>,
  ): Promise<Plugin.NovelItem[]> {
    const url = this.buildSeriesUrl(page, {
      // "Latest" tab wins over the sort picker — the site defaults to recently-updated when sort is omitted.
      sort: showLatestNovels ? undefined : filters?.sort?.value || 'views',
      filters,
    });

    const rscText = await this.fetchRsc(url);
    const pageData = this.extractBrowsePage(rscText);
    if (!pageData) return [];

    return pageData.initialSeries.map(s => ({
      name: s.title,
      path: `/series/novel/${s.urlSlug}`,
      cover: s.coverImage
        ? new URL(s.coverImage, this.site).href
        : defaultCover,
    }));
  }

  private buildSeriesUrl(
    page: number,
    opts: {
      q?: string;
      sort?: string;
      filters?: SeriesUrlFilters;
    } = {},
  ): string {
    const params = new URLSearchParams();

    if (opts.sort) params.set('sort', opts.sort);
    if (opts.q) params.set('q', opts.q);

    const f = opts.filters;

    // Excludable groups — genre and tag have include/exclude halves.
    const addExcludable = (
      value: { include?: string[]; exclude?: string[] } | undefined,
      includeKey: string,
      excludeKey: string,
    ) => {
      if (value?.include?.length) {
        params.set(includeKey, value.include.join(','));
      }
      if (value?.exclude?.length) {
        params.set(excludeKey, value.exclude.join(','));
      }
    };

    addExcludable(f?.genre?.value, 'genre', 'exgenre');
    addExcludable(f?.tag?.value, 'tag', 'extag');

    // Simple multi-select groups — comma-joined, include only.
    const addList = (value: string[] | undefined, key: string) => {
      if (value?.length) params.set(key, value.join(','));
    };

    addList(f?.type?.value, 'type');
    addList(f?.status?.value, 'status');
    addList(f?.origin?.value, 'origin');

    // Boolean toggles — only added when true.
    if (f?.sale?.value) params.set('sale', 'true');
    if (f?.images?.value) params.set('images', 'true');

    // Chapter count range — added only when the user typed something.
    const min = f?.ch_min?.value?.trim();
    const max = f?.ch_max?.value?.trim();
    if (min) params.set('ch_min', min);
    if (max) params.set('ch_max', max);

    if (page > 1) params.set('page', String(page));

    return `${this.site}/series?${params.toString()}`;
  }

  // -----------------------------------------------------------------------
  // HTML fallbacks - used only if RSC parsing fails, RIP 🙏
  // -----------------------------------------------------------------------
  private async parseChapterPage(
    novelPath: string,
    page: string,
  ): Promise<Plugin.ChapterItem[]> {
    const $ = await this.fetchPage(
      `${this.site}${novelPath.split('?')[0]}?page=${page}`,
    );

    let chapters: NoveldexChapter[] = [];

    $('script').each((_, el) => {
      const text = $(el).text();

      if (text.includes('hasAccess')) {
        const chapterStart = text.indexOf('\\"chapters\\":[');
        const chapterEnd = text.indexOf(',\\"characters\\"', chapterStart);

        if (chapterStart === -1 || chapterEnd === -1) return;

        const chaptersText = text.slice(
          chapterStart + '\\"chapters\\":'.length,
          chapterEnd,
        );

        const chaptersJson = chaptersText
          .replace(/\\\\/g, '\\')
          .replace(/\\"/g, '"');

        chapters = JSON.parse(chaptersJson) as NoveldexChapter[];
        return false;
      }
    });

    const clrNovelPath = novelPath.split('?')[0];

    return chapters.map(chapter => ({
      name: chapter.title || 'Untitled',
      path: `${clrNovelPath}/chapter/${chapter.number}`,
      releaseTime: chapter.publishedAt,
      chapterNumber: chapter.number,
    }));
  }

  private async parseNovelFromHtml(
    novelPath: string,
  ): Promise<Plugin.SourceNovel> {
    const $ = await this.fetchPage(`${this.site}${novelPath}`);

    const title = $('h1').text().trim() || '';
    const src = $(`img[alt="${title}"]`).attr('src');
    const cover = src ? new URL(src, this.site).href : undefined;

    let seriesData: NoveldexSeriesData | undefined;

    $('script').each((_, el) => {
      const text = $(el).text();

      if (text.includes('hasAccess')) {
        const jsonStartIdx = text.indexOf('{\\"id\\"');
        const jsonEndIdx = text.indexOf(',\\"chapters\\"', jsonStartIdx);

        if (jsonStartIdx !== -1 && jsonEndIdx !== -1) {
          const seriesText = text.slice(jsonStartIdx, jsonEndIdx);
          const jsonText = seriesText.replace(/\\"/g, '"');
          seriesData = JSON.parse(jsonText) as NoveldexSeriesData;
          return false;
        }
      }
    });

    const chapterCount = seriesData?.chapterCount || 0;
    const totalPages = Math.ceil(chapterCount / 100);

    const allChapters: Plugin.ChapterItem[] = [];
    for (let i = 1; i <= totalPages; i++) {
      const pageChapters = await this.parseChapterPage(novelPath, i.toString());
      allChapters.push(...pageChapters);

      await new Promise(resolve => setTimeout(resolve, 200));
    }

    const description = seriesData?.description
      ?.replace(/\\r\\n/g, '\n')
      ?.replace(/\\n/g, '\n')
      ?.trim();

    const genres = seriesData?.genres?.map(g => g.name) || [];

    return {
      path: novelPath,
      name: title || seriesData?.title || 'Untitled',
      cover: cover || defaultCover,
      status: this.mapStatus(seriesData?.status),
      summary: description,
      genres: genres.join(', '),
      chapters: allChapters,
    };
  }

  // -----------------------------------------------------------------------
  // Main parser — RSC first, HTML fallback
  // -----------------------------------------------------------------------

  async parseNovel(novelPath: string): Promise<Plugin.SourceNovel> {
    const base = novelPath.split('?')[0];

    try {
      const first = await this.fetchSeriesPage(base, 1);

      if (first?.series) {
        const allChapters = this.mapChapters(first.chapters, base);

        // Walk remaining pages — RSC-only
        for (let page = 2; page <= first.totalPages; page++) {
          try {
            const next = await this.fetchSeriesPage(base, page);
            if (next?.chapters?.length) {
              allChapters.push(...this.mapChapters(next.chapters, base));
            }
            await new Promise(r => setTimeout(r, 100));
          } catch (error) {
            console.warn(`Failed to fetch page ${page}:`, error);
          }
        }

        allChapters.sort(
          (a, b) => (a.chapterNumber ?? 0) - (b.chapterNumber ?? 0),
        );

        const s = first.series;

        const cover = s.coverImage
          ? new URL(s.coverImage, this.site).href
          : defaultCover;

        const description = (s.description || '')
          .replace(/\\r\\n/g, '\n')
          .replace(/\\n/g, '\n')
          .trim();

        const genres =
          s.genres
            ?.map(g => g.name)
            .filter(Boolean)
            .join(', ') || '';

        return {
          path: base,
          name: s.title || 'Untitled',
          cover,
          status: this.mapStatus(s.status),
          summary: description,
          genres,
          chapters: allChapters,
        };
      }
    } catch {
      // fall through to the HTML scraper
    }

    /*
            Next.js's flight format is not a stable public API
            If noveldex upgrades next.js, Client Component returns null so to make sure the code still work
            We fall back on extracting with html + cheerio, we lose speed but it works.
        */

    return this.parseNovelFromHtml(base);
  }

  // Chapter content helper
  private extractDeferredText(
    rscText: string,
    refId: string,
  ): string | undefined {
    const esc = refId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    const m = new RegExp(`(?:^|\\n)${esc}:T([0-9a-fA-F]+),`).exec(rscText);
    if (!m) return undefined;
    const start = m.index + m[0].length;
    const bytes = new TextEncoder().encode(rscText.slice(start));
    return new TextDecoder().decode(bytes.slice(0, parseInt(m[1], 16)));
  }

  // Main chapter content
  async parseChapter(chapterPath: string): Promise<string> {
    const url = `${this.site}${chapterPath}`;
    const rscText = await this.fetchRsc(url);

    // Checking whether the chapter is free
    if (/"isUnlocked"\s*:\s*false/.test(rscText)) {
      throw new Error(
        'This chapter requires premium access and cannot be read here.',
      );
    }

    // Decrypting starts

    // 1. Locate the xorEncryption block
    const xorMatch = rscText.match(/"xorEncryption"\s*:\s*(\{[^}]+\})/);
    if (!xorMatch)
      throw new Error(
        'Could not load chapter. It may require premium access or a purchase.',
      );

    const xor = JSON.parse(xorMatch[1]) as {
      encryptedBase64: string;
      partialKeyHint: string;
      timestamp: number;
      clientNonce: string;
    };

    // 2. Resolve "$64" → line "64:T<hexlen>,<base64>"
    let b64: string;
    const refMatch = /^\$([0-9a-zA-Z]+)$/.exec(xor.encryptedBase64);

    if (refMatch) {
      const esc = refMatch[1].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
      const m = new RegExp(`(?:^|\\n)${esc}:T([0-9a-fA-F]+),`).exec(rscText);
      if (!m) throw new Error('noveldex: cannot resolve encrypted ref');

      const start = m.index + m[0].length;
      const byteLen = parseInt(m[1], 16);
      const bytes = new TextEncoder().encode(rscText.slice(start));
      b64 = new TextDecoder().decode(bytes.slice(0, byteLen));
    } else {
      b64 = xor.encryptedBase64;
    }

    // 3. Decrypt
    const cipher = base64ToBytes(b64);
    const key = deriveNoveldexKey(
      xor.partialKeyHint,
      xor.timestamp,
      xor.clientNonce,
    );
    const content = new TextDecoder('utf-8').decode(xorDecrypt(cipher, key));

    if (!content?.trim()) throw new Error('noveldex: empty chapter');

    // 4. Normalize
    return (
      content
        .replace(/\r\n/g, '\n')
        .replace(/\r/g, '\n')
        // Make NovelDex hosted images absolute.
        //   src="/uploads/..."  →  src="https://noveldex.io/uploads/..."
        .replace(/(<img\b[^>]*?\bsrc=")\/(?!\/)([^"]*")/gi, `$1${this.site}/$2`)
        /*
                    Unwrap stray <p> wrapping around block-level <div>s.
                    NovelDex emits <p><div>...</div></p> — invalid HTML that
                    breaks the system-UI card layout in the reader WebView.
                */
        .replace(/<p>\s*(<div\b[^>]*>)/gi, '$1')
        .replace(/(<\/div>)\s*<\/p>/gi, '$1')

        /*
                    Collapse <br> runs adjacent to block-level tags. 
                    Every source line ends in <br>, which doubles spacing around the styled div blocks.
                */
        .replace(/(<\/(?:p|div|figure)>)\s*(?:<br\s*\/?>\s*)+/gi, '$1')
        .replace(/(?:<br\s*\/?>\s*)+(<(?:p|div|figure)\b)/gi, '$1')

        .replace(/style="([^"]*?)"/g, (match, styles) =>
          /border|background|box-shadow/.test(styles)
            ? `style="font-family:'JetBrains Mono','SFMono-Regular',Consolas,'Liberation Mono',Menlo,monospace;${styles}"`
            : match,
        )
        /*
                    Split into chunks and wrap plain-text ones. 
                    Chunks that already begin with a block-level tag pass through as-is
                    so we don't nest <p> inside <p>.
                */

        .split(/\n{2,}/)
        .map(p => p.trim())
        .filter(Boolean)
        .map(p =>
          /^<(?:p|div|figure|img|h[1-6]|blockquote|hr|ul|ol)\b/i.test(p)
            ? p
            : `<p>${p.replace(/\n/g, '<br>')}</p>`,
        )
        .join('')
    );
  }

  // Search starts
  // Bridge between raw RSC and structured data
  private extractBrowsePage(rscText: string): SeriesBrowsePage | null {
    const clientId = this.findClientId(rscText, 'SeriesBrowseGrid');
    if (!clientId) return null;

    const marker = `"$L${clientId}",null,`;

    let idx = rscText.indexOf(marker);
    while (idx !== -1) {
      const jsonText = this.extractBalancedJson(rscText, idx + marker.length);
      if (jsonText) {
        try {
          const parsed = JSON.parse(jsonText);
          if (parsed && Array.isArray(parsed.initialSeries)) {
            return parsed as SeriesBrowsePage;
          }
        } catch {
          // try the next occurrence
        }
      }
      idx = rscText.indexOf(marker, idx + marker.length);
    }

    return null;
  }

  async searchNovels(
    searchTerm: string,
    pageNo: number,
  ): Promise<Plugin.NovelItem[]> {
    if (!searchTerm.trim()) return [];

    const params = new URLSearchParams({ q: searchTerm, sort: 'views' });
    if (pageNo > 1) params.set('page', String(pageNo));

    const rscText = await this.fetchRsc(
      `${this.site}/series?${params.toString()}`,
    );

    const page = this.extractBrowsePage(rscText);
    if (!page) return [];

    return page.initialSeries.map(s => ({
      name: s.title,
      path: `/series/novel/${s.urlSlug}`,
      cover: s.coverImage
        ? new URL(s.coverImage, this.site).href
        : defaultCover,
    }));
  }

  resolveUrl = (path: string) => this.site + path;
}

export default new Noveldex();