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

type APINovel = {
  title: string;
  slug: string;
  cover: string;
  description: string;
  status: string;
  genres: { name: string }[];
  user?: {
    username?: string;
    name?: string;
  };
};

type APIChapter = {
  id: number;
  locked: { price: number } | null;
  group: null | {
    index: number;
    slug: string;
  };
  title: string;
  slug: string;
  number: number;
  created_at: string;
};

type ChapterInfo = {
  name: string;
  path: string;
  releaseTime: string;
  chapterNumber: number;
};

type Chapter = {
  type: string;
  content: {
    type: string;
    attrs?: Attrs;
    content: {
      type: string;
      text?: string;
      marks?: {
        type: string;
        attrs?: Attrs;
      }[];
    }[];
  }[];
};

type Attrs = {
  textAlign?: string;
  href?: string;
  level?: number;
};

type Nodes = {
  type: string;
  nodes?: {
    type: string;
    // couldnt find the sveltekit so disable eslint here
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    data: any[];
  }[];
};

class FenrirRealmPlugin implements Plugin.PluginBase {
  id = 'fenrir';
  name = 'Fenrir Realm';
  icon = 'src/en/fenrirrealm/icon.png';
  site = 'https://fenrirealm.com';
  version = '1.1.2';
  imageRequestInit?: Plugin.ImageRequestInit | undefined = undefined;

  hideLocked = storage.get('hideLocked');
  pluginSettings = {
    hideLocked: {
      value: '',
      label: 'Hide locked chapters',
      type: 'Switch',
    },
  };

  //flag indicates whether access to LocalStorage, SesesionStorage is required.
  webStorageUtilized?: boolean;

  async popularNovels(
    pageNo: number,
    {
      showLatestNovels,
      filters,
    }: Plugin.PopularNovelsOptions<typeof this.filters>,
  ): Promise<Plugin.NovelItem[]> {
    const params = new URLSearchParams({
      page: pageNo.toString(),
      per_page: '20',
      status: filters.status.value,
      order: showLatestNovels ? 'latest' : filters.sort.value,
    });
    filters.genres.value.forEach(g => params.append('genres[]', g));

    const res = await fetchApi(
      `${this.site}/api/series/filter?${params.toString()}`,
    ).then(r =>
      r.json().catch(() => {
        throw new Error(
          'There was an error fetching the data from the server. Please try to open it in WebView',
        );
      }),
    );

    return (res.data || []).map((r: APINovel) => this.parseNovelFromApi(r));
  }

  async parseNovel(novelPath: string): Promise<Plugin.SourceNovel> {
    let cleanNovelPath = novelPath;
    let apiRes = await fetchApi(
      `${this.site}/api/new/v2/series/${novelPath}/chapters`,
      {},
    );

    if (!apiRes.ok) {
      const slugMatch = novelPath.match(/^\d+-(.+)$/);
      const searchSlug = slugMatch ? slugMatch[1] : novelPath;
      apiRes = await fetchApi(
        `${this.site}/api/new/v2/series/${searchSlug}/chapters`,
        {},
      );
      cleanNovelPath = searchSlug;

      if (!apiRes.ok) {
        const words = searchSlug.replace(/-/g, ' ').split(' ');
        const SearchStr = words.find(w => w.length > 3) || words[0];
        const searchRes = await fetchApi(
          `${this.site}/api/series/filter?page=1&per_page=20&search=${encodeURIComponent(SearchStr)}`,
        ).then(r => r.json());

        if (searchRes.data && searchRes.data.length > 0) {
          cleanNovelPath = searchRes.data[0].slug;
          apiRes = await fetchApi(
            `${this.site}/api/new/v2/series/${cleanNovelPath}/chapters`,
            {},
          );
        }
      }

      if (!apiRes.ok) {
        throw new Error(
          'Novel not found. It may have been removed or its URL changed significantly.',
        );
      }
    }

    const seriesData: APINovel = await fetchApi(
      `${this.site}/api/new/v2/series/${cleanNovelPath}`,
    ).then(r => r.json());
    const summaryCheerio = loadCheerio(seriesData.description || '');

    const novel: Plugin.SourceNovel = {
      path: cleanNovelPath,
      name: seriesData.title || '',
      summary:
        summaryCheerio('p').length > 0
          ? summaryCheerio('p')
              .map((_, el) => loadCheerio(el).text())
              .get()
              .join('\n\n')
          : summaryCheerio.text() || '',
      author: seriesData.user?.name || seriesData.user?.username || '',
      cover: seriesData.cover
        ? this.site + '/' + seriesData.cover
        : defaultCover,
      genres: (seriesData.genres || []).map(g => g.name).join(','),
      status: seriesData.status || 'Unknown',
    };

    let chapters = await apiRes.json();

    if (this.hideLocked) {
      chapters = chapters.filter((c: APIChapter) => !c.locked?.price);
    }

    novel.chapters = chapters
      .map((c: APIChapter) => ({
        name:
          (c.locked?.price ? '🔒 ' : '') +
          (c.group?.index == null ? '' : 'Vol ' + c.group?.index + ' ') +
          'Chapter ' +
          c.number +
          (c.title && c.title.trim() != 'Chapter ' + c.number
            ? ' - ' + c.title.replace(/^chapter [0-9]+ . /i, '')
            : ''),
        path:
          novelPath +
          (c.group?.index == null ? '' : '/' + c.group?.slug) +
          '/' +
          (c.slug || 'chapter-' + c.number) +
          '~~' +
          c.id,
        releaseTime: c.created_at,
        chapterNumber: c.number + (c.group?.index || 0) * 10000,
      }))
      .sort(
        (a: ChapterInfo, b: ChapterInfo) => a.chapterNumber - b.chapterNumber,
      );
    return novel;
  }

  async parseChapter(chapterPath: string): Promise<string> {
    const chapterId = chapterPath.split('~~')[1];
    if (chapterId) {
      const url = `${this.site}/api/new/v2/chapters/${chapterId}`;
      const res = await fetchApi(url);
      const json = await res.json();
      const content = json.content;

      if (content) {
        try {
          // Attempt 1: Handle legacy stringified TipTap JSON AST schema
          const parsedContent: Chapter = JSON.parse(content);
          if (parsedContent.type === 'doc') {
            return parsedContent.content
              .map(node => {
                if (node.type === 'paragraph') {
                  const innerHtml =
                    node.content
                      ?.map(c => {
                        if (c.type === 'text') {
                          let text = c.text;
                          if (c.marks) {
                            for (const mark of c.marks) {
                              if (mark.type === 'bold') text = `<b>${text}</b>`;
                              if (mark.type === 'italic')
                                text = `<i>${text}</i>`;
                              if (mark.type === 'underline')
                                text = `<u>${text}</u>`;
                              if (mark.type === 'strike')
                                text = `<strike>${text}</strike>`;
                              if (mark.type === 'link')
                                text = `<a href="${mark.attrs?.href}">${text}</a>`;
                            }
                          }
                          return text;
                        }
                        if (c.type === 'hardBreak') return '<br>';
                        return '';
                      })
                      .join('') || '';
                  return `<p>${innerHtml}</p>`;
                }
                if (node.type === 'heading') {
                  const level = node.attrs?.level || 1;
                  const innerHtml =
                    node.content?.map(c => c.text).join('') || '';
                  return `<h${level}>${innerHtml}</h${level}>`;
                }
                return '';
              })
              .join('\n');
          }
        } catch {
          /**
           * HTML Response Cleaner:
           * Fenrir Realm inserts anti-scraping & watermark elements:
           * 1. Scramble hidden divs (`div[aria-hidden="true"]`)
           * 2. Inline `<style>` blocks
           * 3. Reader attributions / Copy references (`.reader-attribution`, `[data-fr-attr]`)
           */
          const $ = loadCheerio(content);

          // Remove anti-scraping tags and inline CSS
          $('div[aria-hidden="true"]').remove();
          $('p[aria-hidden="true"]').remove();
          $('.reader-attribution').remove();
          $('[data-fr-attr]').remove();
          $('style').remove();

          // Target any remaining text elements containing copy references or bookmarks
          $('p, div, span, small').each((_, el) => {
            const text = $(el).text().trim();
            if (
              text.startsWith('Copy reference:') ||
              text.startsWith('Bookmark:')
            ) {
              $(el).remove();
            }
          });

          return $.html() || content;
        }
      }
    }

    // Fallback or old method
    const url = `${this.site}/series/${chapterPath.split('~~')[0]}`;
    const result = await fetchApi(url);
    const body = await result.text();

    const loadedCheerio = loadCheerio(body);

    // Clean up anti-scraping and watermark elements first
    loadedCheerio('[aria-hidden="true"]').remove();
    loadedCheerio('.reader-attribution').remove();
    loadedCheerio('[data-fr-attr]').remove();

    let chapterText = loadedCheerio(
      '.reader-area p, div.content-area p, [id^="reader-area"] p',
    )
      .map((_, el) => {
        const html = loadedCheerio(el).html()?.trim();
        return html ? `<p>${html}</p>` : '';
      })
      .get()
      .filter(Boolean)
      .join('\n');

    if (chapterText) {
      return chapterText;
    }

    // Fallback to SvelteKit JSON if HTML parsing fails or is empty
    try {
      const jsonUrl = `${this.site}/series/${chapterPath.split('~~')[0]}/__data.json?x-sveltekit-invalidated=001`;
      const jsonRes = await fetchApi(jsonUrl);
      const json: Nodes = await jsonRes.json();

      const nodes = json.nodes;
      const data = nodes?.find(n => n.type === 'data')?.data;
      if (data) {
        const contentStr = data.find(
          d => typeof d === 'string' && d.includes('{"type":"doc"'),
        );

        if (contentStr) {
          const contentJson: Chapter = JSON.parse(contentStr);
          if (contentJson.type === 'doc') {
            chapterText = contentJson.content
              .map(node => {
                if (node.type === 'paragraph') {
                  const innerHtml =
                    node.content
                      ?.map(c => {
                        if (c.type === 'text') {
                          let text = c.text;
                          if (c.marks) {
                            for (const mark of c.marks) {
                              if (mark.type === 'bold') text = `<b>${text}</b>`;
                              if (mark.type === 'italic')
                                text = `<i>${text}</i>`;
                            }
                          }
                          return text;
                        }
                        return '';
                      })
                      .join('') || '';
                  return `<p>${innerHtml}</p>`;
                }
                return '';
              })
              .join('\n');
          }
        }
      }
    } catch (e) {
      // ignore
    }

    return chapterText;
  }

  async searchNovels(
    searchTerm: string,
    pageNo: number,
  ): Promise<Plugin.NovelItem[]> {
    let url = `${this.site}/api/series/filter?page=${pageNo}&per_page=20&search=${encodeURIComponent(
      searchTerm,
    )}`;
    let res = await fetchApi(url).then(r => r.json());

    if (pageNo === 1 && (!res.data || res.data.length === 0)) {
      const words = searchTerm.split(' ');
      const fallbackTerm = words.find(w => w.length > 3) || words[0];
      if (fallbackTerm && fallbackTerm !== searchTerm) {
        url = `${this.site}/api/series/filter?page=${pageNo}&per_page=20&search=${encodeURIComponent(
          fallbackTerm,
        )}`;
        res = await fetchApi(url).then(r => r.json());
      }
    }

    return (res.data || []).map((novel: APINovel) =>
      this.parseNovelFromApi(novel),
    );
  }

  parseNovelFromApi(apiData: APINovel) {
    return {
      name: apiData.title,
      path: apiData.slug,
      cover: this.site + '/' + apiData.cover,
      summary: apiData.description,
      status: apiData.status,
      genres: apiData.genres.map(g => g.name).join(','),
    };
  }

  resolveUrl(path: string): string {
    return `${this.site}/series/${path.split('~~')[0]}`;
  }

  filters = {
    status: {
      type: FilterTypes.Picker,
      label: 'Status',
      value: 'any',
      options: [
        { label: 'All', value: 'any' },
        { label: 'Ongoing', value: 'ongoing' },
        {
          label: 'Completed',
          value: 'completed',
        },
      ],
    },
    sort: {
      type: FilterTypes.Picker,
      label: 'Sort',
      value: 'popular',
      options: [
        { label: 'Popular', value: 'popular' },
        { label: 'Latest', value: 'latest' },
        { label: 'Updated', value: 'updated' },
      ],
    },
    genres: {
      type: FilterTypes.CheckboxGroup,
      label: 'Genres',
      value: [],
      options: [
        { 'label': 'Action', 'value': '1' },
        { 'label': 'Adult', 'value': '2' },
        {
          'label': 'Adventure',
          'value': '3',
        },
        { 'label': 'Comedy', 'value': '4' },
        { 'label': 'Drama', 'value': '5' },
        {
          'label': 'Ecchi',
          'value': '6',
        },
        { 'label': 'Fantasy', 'value': '7' },
        { 'label': 'Gender Bender', 'value': '8' },
        {
          'label': 'Harem',
          'value': '9',
        },
        { 'label': 'Historical', 'value': '10' },
        { 'label': 'Horror', 'value': '11' },
        {
          'label': 'Josei',
          'value': '12',
        },
        { 'label': 'Martial Arts', 'value': '13' },
        { 'label': 'Mature', 'value': '14' },
        {
          'label': 'Mecha',
          'value': '15',
        },
        { 'label': 'Mystery', 'value': '16' },
        { 'label': 'Psychological', 'value': '17' },
        {
          'label': 'Romance',
          'value': '18',
        },
        { 'label': 'School Life', 'value': '19' },
        { 'label': 'Sci-fi', 'value': '20' },
        {
          'label': 'Seinen',
          'value': '21',
        },
        { 'label': 'Shoujo', 'value': '22' },
        { 'label': 'Shoujo Ai', 'value': '23' },
        {
          'label': 'Shounen',
          'value': '24',
        },
        { 'label': 'Shounen Ai', 'value': '25' },
        { 'label': 'Slice of Life', 'value': '26' },
        {
          'label': 'Smut',
          'value': '27',
        },
        { 'label': 'Sports', 'value': '28' },
        { 'label': 'Supernatural', 'value': '29' },
        {
          'label': 'Tragedy',
          'value': '30',
        },
        { 'label': 'Wuxia', 'value': '31' },
        { 'label': 'Xianxia', 'value': '32' },
        {
          'label': 'Xuanhuan',
          'value': '33',
        },
        { 'label': 'Yaoi', 'value': '34' },
        { 'label': 'Yuri', 'value': '35' },
      ],
    },
  } satisfies Filters;
}

export default new FenrirRealmPlugin();