// Package eromuse implements the EroMuse adult manga base.
// GET {base}/comics/album/Various-Authors; album-based crawl.
package eromuse

import (
	"context"
	"fmt"
	"net/http"
	"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("eromuse: HTTP %d", resp.StatusCode)
	}
	return goquery.NewDocumentFromReader(resp.Body)
}

func (s *Source) parseMangaList(doc *goquery.Document) ([]source.SManga, string) {
	var mangas []source.SManga
	doc.Find("a.c-tile:has(img)").Each(func(_ int, el *goquery.Selection) {
		// skip members-only
		if el.Find(".members-only").Length() > 0 {
			return
		}
		m := source.SManga{}
		m.URL, _ = el.Attr("href")
		m.Title = strings.TrimSpace(el.Find("span.title, .c-tile-title").Text())
		if m.Title == "" {
			m.Title = strings.TrimSpace(el.AttrOr("title", ""))
		}
		el.Find("img").First().Each(func(_ int, img *goquery.Selection) {
			m.ThumbnailURL = imgAttr(img, s.cfg.BaseURL)
		})
		if m.URL != "" {
			mangas = append(mangas, m)
		}
	})
	// next page selector
	nextURL := ""
	doc.Find(".pagination span.current + span a").First().Each(func(_ int, a *goquery.Selection) {
		nextURL, _ = a.Attr("href")
	})
	return mangas, nextURL
}

func (s *Source) fetchPage(rawURL string) (source.MangasPage, error) {
	doc, err := s.get(context.Background(), rawURL)
	if err != nil {
		return source.MangasPage{}, err
	}
	mangas, next := s.parseMangaList(doc)
	return source.MangasPage{Mangas: mangas, HasNextPage: next != ""}, nil
}

func (s *Source) GetPopularManga(page int) (source.MangasPage, error) {
	u := fmt.Sprintf("%s/comics/album/Various-Authors", s.base())
	if page > 1 {
		u = fmt.Sprintf("%s/comics/album/Various-Authors?page=%d", s.base(), page)
	}
	return s.fetchPage(u)
}

func (s *Source) GetLatestUpdates(page int) (source.MangasPage, error) {
	u := fmt.Sprintf("%s/comics/album/Various-Authors?sort=date", s.base())
	if page > 1 {
		u = fmt.Sprintf("%s/comics/album/Various-Authors?sort=date&page=%d", s.base(), page)
	}
	return s.fetchPage(u)
}

func (s *Source) GetSearchManga(page int, query string, filters []source.Filter) (source.MangasPage, error) {
	u := fmt.Sprintf("%s/search?q=%s", s.base(), query)
	if page > 1 {
		u += fmt.Sprintf("&page=%d", page)
	}
	return s.fetchPage(u)
}

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}
	// breadcrumb: li[2] = author, li[3] = album
	crumbs := doc.Find("div.top-menu-breadcrumb li")
	if crumbs.Length() >= 2 {
		result.Author = strings.TrimSpace(crumbs.Eq(1).Text())
	}
	if crumbs.Length() >= 3 {
		result.Title = strings.TrimSpace(crumbs.Eq(2).Text())
	}
	if result.Title == "" {
		result.Title = manga.Title
	}
	result.ThumbnailURL = imgAttr(doc.Find(".c-tile img, .album-cover img").First(), s.cfg.BaseURL)
	result.Description = strings.TrimSpace(doc.Find(".album-description, .description").Text())
	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
	}
	var chapters []source.SChapter
	// linked chapters
	doc.Find("a.c-tile[href*='/comics/']").Each(func(_ int, a *goquery.Selection) {
		ch := source.SChapter{}
		ch.URL, _ = a.Attr("href")
		ch.Name = strings.TrimSpace(a.Find("span.title, .c-tile-title").Text())
		if ch.Name == "" {
			ch.Name = strings.TrimSpace(a.AttrOr("title", ch.URL))
		}
		if ch.URL != "" {
			chapters = append(chapters, ch)
		}
	})
	// if no sub-chapters, the manga itself is the chapter
	if len(chapters) == 0 {
		chapters = append(chapters, source.SChapter{
			URL:  manga.URL,
			Name: manga.Title,
		})
	}
	return chapters, nil
}

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(".read-img img, .pages img, .comic-page 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})
		}
	})
	// paginated pages: follow next links
	nextURL := ""
	doc.Find(".pagination span.current + span a").First().Each(func(_ int, a *goquery.Selection) {
		nextURL, _ = a.Attr("href")
	})
	for nextURL != "" && len(pages) < 500 {
		nextDoc, err := s.get(context.Background(), util.AbsURL(s.cfg.BaseURL, nextURL))
		if err != nil {
			break
		}
		nextDoc.Find(".read-img img, .pages img, .comic-page img").Each(func(_ int, img *goquery.Selection) {
			if u := imgAttr(img, s.cfg.BaseURL); u != "" {
				pages = append(pages, source.Page{Index: len(pages), ImageURL: u})
			}
		})
		nextURL = ""
		nextDoc.Find(".pagination span.current + span a").First().Each(func(_ int, a *goquery.Selection) {
			nextURL, _ = a.Attr("href")
		})
	}
	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 ""
}