// Package scanreader implements the ScanReader French manga base.
// GET {base}/bibliotheque/page/{n-1}/?sort=views; WordPress AJAX chapters.
package scanreader

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"

	"github.com/PuerkitoBio/goquery"

	"goyomi/internal/httpclient"
	"goyomi/internal/source"
	"goyomi/sources/base/util"
)

type Config struct {
	Name    string
	BaseURL string
	Lang    string
}

type Source struct {
	cfg    Config
	client *httpclient.Client
	id     int64
}

func New(cfg Config) *Source {
	c := httpclient.NewClient(httpclient.WithRateLimit(1, 2))
	return &Source{cfg: cfg, client: c, id: source.GenerateSourceID(cfg.Name, cfg.Lang)}
}

func (s *Source) ID() int64            { return s.id }
func (s *Source) Name() string         { return s.cfg.Name }
func (s *Source) Lang() string         { return s.cfg.Lang }
func (s *Source) SupportsLatest() bool { return true }

func (s *Source) base() string { return strings.TrimRight(s.cfg.BaseURL, "/") }

func (s *Source) get(ctx context.Context, rawURL string) (*goquery.Document, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Referer", s.cfg.BaseURL+"/")
	resp, err := s.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("scanreader: HTTP %d", resp.StatusCode)
	}
	return goquery.NewDocumentFromReader(resp.Body)
}

func mangaFromCard(el *goquery.Selection, baseURL string) source.SManga {
	m := source.SManga{}
	el.Find("a").First().Each(func(_ int, a *goquery.Selection) {
		m.URL, _ = a.Attr("href")
		m.Title = strings.TrimSpace(a.AttrOr("title", a.Text()))
	})
	m.ThumbnailURL = imgAttr(el.Find("img").First(), baseURL)
	return m
}

func (s *Source) GetPopularManga(page int) (source.MangasPage, error) {
	if page == 1 {
		doc, err := s.get(context.Background(), s.base())
		if err != nil {
			return source.MangasPage{}, err
		}
		var mangas []source.SManga
		doc.Find("div.popular-section div.manga-card").Each(func(_ int, el *goquery.Selection) {
			m := mangaFromCard(el, s.cfg.BaseURL)
			if m.URL != "" {
				mangas = append(mangas, m)
			}
		})
		return source.MangasPage{Mangas: mangas, HasNextPage: true}, nil
	}
	doc, err := s.get(context.Background(), fmt.Sprintf("%s/bibliotheque/page/%d/?sort=views", s.base(), page-1))
	if err != nil {
		return source.MangasPage{}, err
	}
	var mangas []source.SManga
	doc.Find("div.manga-card").Each(func(_ int, el *goquery.Selection) {
		m := mangaFromCard(el, s.cfg.BaseURL)
		if m.URL != "" {
			mangas = append(mangas, m)
		}
	})
	hasNext := doc.Find("a.pagination-next").Length() > 0
	return source.MangasPage{Mangas: mangas, HasNextPage: hasNext}, nil
}

func (s *Source) GetLatestUpdates(page int) (source.MangasPage, error) {
	doc, err := s.get(context.Background(), fmt.Sprintf("%s/dernieres-sorties/page/%d/", s.base(), page))
	if err != nil {
		return source.MangasPage{}, err
	}
	var mangas []source.SManga
	doc.Find("div.manga-cover, div.manga-card").Each(func(_ int, el *goquery.Selection) {
		m := mangaFromCard(el, s.cfg.BaseURL)
		if m.URL != "" {
			mangas = append(mangas, m)
		}
	})
	hasNext := doc.Find("a.pagination-next").Length() > 0
	return source.MangasPage{Mangas: mangas, HasNextPage: hasNext}, nil
}

func (s *Source) GetSearchManga(page int, query string, filters []source.Filter) (source.MangasPage, error) {
	doc, err := s.get(context.Background(), fmt.Sprintf("%s/?s=%s&post_type=manga", s.base(), url.QueryEscape(query)))
	if err != nil {
		return source.MangasPage{}, err
	}
	var mangas []source.SManga
	doc.Find("div.manga-card").Each(func(_ int, el *goquery.Selection) {
		m := mangaFromCard(el, s.cfg.BaseURL)
		if m.URL != "" {
			mangas = append(mangas, m)
		}
	})
	return source.MangasPage{Mangas: mangas, HasNextPage: false}, nil
}

func (s *Source) GetMangaDetails(manga source.SManga) (source.SManga, error) {
	doc, err := s.get(context.Background(), util.AbsURL(s.cfg.BaseURL, manga.URL))
	if err != nil {
		return manga, err
	}
	result := source.SManga{URL: manga.URL}
	result.Title = strings.TrimSpace(doc.Find("h1.manga-title").Text())
	if result.Title == "" {
		result.Title = manga.Title
	}
	if v, ok := doc.Find("meta[property='og:image']").First().Attr("content"); ok {
		result.ThumbnailURL = v
	}
	result.Description = strings.TrimSpace(doc.Find("div.manga-content div[style*='background: #333'] p").Text())
	doc.Find("div.manga-info-grid > div").Each(func(_ int, row *goquery.Selection) {
		label := strings.ToLower(strings.TrimSpace(row.Find("div:first-child").Text()))
		val := strings.TrimSpace(row.Find("div:last-child").Text())
		switch {
		case strings.Contains(label, "auteur"):
			result.Author = val
		case strings.Contains(label, "statut"):
			result.Status = util.StatusFromString(val)
		case strings.Contains(label, "genre"):
			var genres []string
			row.Find("span, a").Each(func(_ int, el *goquery.Selection) {
				if t := strings.TrimSpace(el.Text()); t != "" {
					genres = append(genres, t)
				}
			})
			result.Genre = strings.Join(genres, ", ")
		}
	})
	return result, nil
}

func (s *Source) GetChapterList(manga source.SManga) ([]source.SChapter, error) {
	doc, err := s.get(context.Background(), util.AbsURL(s.cfg.BaseURL, manga.URL))
	if err != nil {
		return nil, err
	}
	container := doc.Find("#secure-chapters-container")
	if container.Length() == 0 {
		// try direct chapter list
		return s.parseChapterList(doc), nil
	}
	mangaID := container.AttrOr("data-manga-id", "")
	nonce := container.AttrOr("data-nonce", "")
	if mangaID == "" || nonce == "" {
		return s.parseChapterList(doc), nil
	}
	// POST admin-ajax.php to get chapters HTML
	formData := url.Values{
		"action":   {"get_chapters"},
		"manga_id": {mangaID},
		"nonce":    {nonce},
	}
	req, err := http.NewRequestWithContext(context.Background(), http.MethodPost,
		s.base()+"/wp-admin/admin-ajax.php",
		strings.NewReader(formData.Encode()))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Set("Referer", s.cfg.BaseURL+"/")
	resp, err := s.client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	// try to unwrap AjaxResponse {"data": "<html>"}, else use raw
	var ajax struct{ Data string `json:"data"` }
	htmlStr := string(body)
	if json.Unmarshal(body, &ajax) == nil && ajax.Data != "" {
		htmlStr = ajax.Data
	}
	ajaxDoc, err := goquery.NewDocumentFromReader(strings.NewReader(htmlStr))
	if err != nil {
		return nil, err
	}
	return s.parseChapterList(ajaxDoc), nil
}

func (s *Source) parseChapterList(doc *goquery.Document) []source.SChapter {
	var chapters []source.SChapter
	doc.Find("h4").Each(func(_ int, h4 *goquery.Selection) {
		var chURL string
		h4.Parents().Each(func(_ int, ancestor *goquery.Selection) {
			if chURL != "" {
				return
			}
			if href, ok := ancestor.Find("a[href*='/chapitre/']").First().Attr("href"); ok {
				chURL = href
			}
		})
		if chURL == "" {
			if href, ok := h4.Find("a").First().Attr("href"); ok {
				chURL = href
			}
		}
		if chURL == "" {
			return
		}
		ch := source.SChapter{
			URL:  chURL,
			Name: strings.TrimSpace(h4.Text()),
		}
		chapters = append(chapters, ch)
	})
	// fallback: li-based
	if len(chapters) == 0 {
		doc.Find("li.chapter-item, .chapter-list li").Each(func(_ int, el *goquery.Selection) {
			ch := source.SChapter{}
			el.Find("a").First().Each(func(_ int, a *goquery.Selection) {
				ch.URL, _ = a.Attr("href")
				ch.Name = strings.TrimSpace(a.Text())
			})
			if ch.URL != "" {
				chapters = append(chapters, ch)
			}
		})
	}
	return chapters
}

func (s *Source) GetPageList(chapter source.SChapter) ([]source.Page, error) {
	doc, err := s.get(context.Background(), util.AbsURL(s.cfg.BaseURL, chapter.URL))
	if err != nil {
		return nil, err
	}
	var pages []source.Page
	doc.Find("div.reading-content img, .chapter-container img, #chapter-images img").Each(func(i int, img *goquery.Selection) {
		if u := imgAttr(img, s.cfg.BaseURL); u != "" {
			pages = append(pages, source.Page{Index: i, ImageURL: u})
		}
	})
	return pages, nil
}

func (s *Source) GetImageURL(page source.Page) (string, error) { return page.ImageURL, nil }
func (s *Source) GetFilterList() []source.Filter               { return nil }

func imgAttr(img *goquery.Selection, baseURL string) string {
	for _, attr := range []string{"data-lazy-src", "data-src", "data-cfsrc", "src"} {
		if v, ok := img.Attr(attr); ok && v != "" && !strings.HasPrefix(v, "data:") {
			return util.AbsURL(baseURL, v)
		}
	}
	return ""
}