// Package mangadventure implements the MangAdventure Django REST API base.
// API: GET {base}/api/v2/series/, GET {base}/api/v2/chapters/
package mangadventure

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

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

type Config struct {
	Name    string
	BaseURL string
	Lang    string
}

type seriesDTO struct {
	Slug        string   `json:"slug"`
	Title       string   `json:"title"`
	Description string   `json:"description"`
	Cover       string   `json:"cover"`
	Authors     []string `json:"authors"`
	Artists     []string `json:"artists"`
	Status      string   `json:"status"`
	Categories  []struct{ Name string `json:"name"` } `json:"categories"`
}

type paginator struct {
	Count   int         `json:"count"`
	Last    bool        `json:"last"`
	Results json.RawMessage `json:"results"`
}

type chapterDTO struct {
	ID         int    `json:"id"`
	Slug       string `json:"slug"`
	Title      string `json:"title"`
	Number     float32 `json:"number"`
	Volume     int    `json:"volume"`
	Published  string `json:"published"`
	Series     string `json:"series"`
}

type pageDTO struct {
	Number int    `json:"number"`
	Image  string `json:"image"`
}

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) api() string { return strings.TrimRight(s.cfg.BaseURL, "/") + "/api/v2" }

func (s *Source) getJSON(ctx context.Context, rawURL string, out any) error {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
	if err != nil {
		return err
	}
	resp, err := s.client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("mangadventure: HTTP %d", resp.StatusCode)
	}
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	return json.Unmarshal(body, out)
}

func (s *Source) toSManga(d seriesDTO) source.SManga {
	genres := make([]string, len(d.Categories))
	for i, c := range d.Categories {
		genres[i] = c.Name
	}
	return source.SManga{
		URL:          fmt.Sprintf("/api/v2/series/%s/", d.Slug),
		Title:        d.Title,
		Author:       strings.Join(d.Authors, ", "),
		Artist:       strings.Join(d.Artists, ", "),
		Description:  d.Description,
		Genre:        strings.Join(genres, ", "),
		Status:       util.StatusFromString(d.Status),
		ThumbnailURL: d.Cover,
	}
}

func (s *Source) GetPopularManga(page int) (source.MangasPage, error) {
	u, _ := url.Parse(s.api() + "/series/")
	q := u.Query()
	q.Set("page", fmt.Sprintf("%d", page))
	q.Set("sort", "-views")
	u.RawQuery = q.Encode()
	var pg paginator
	if err := s.getJSON(context.Background(), u.String(), &pg); err != nil {
		return source.MangasPage{}, err
	}
	var series []seriesDTO
	if err := json.Unmarshal(pg.Results, &series); err != nil {
		return source.MangasPage{}, err
	}
	mangas := make([]source.SManga, len(series))
	for i, s2 := range series {
		mangas[i] = s.toSManga(s2)
	}
	return source.MangasPage{Mangas: mangas, HasNextPage: !pg.Last}, nil
}

func (s *Source) GetLatestUpdates(page int) (source.MangasPage, error) {
	u, _ := url.Parse(s.api() + "/series/")
	q := u.Query()
	q.Set("page", fmt.Sprintf("%d", page))
	q.Set("sort", "-latest_upload")
	u.RawQuery = q.Encode()
	var pg paginator
	if err := s.getJSON(context.Background(), u.String(), &pg); err != nil {
		return source.MangasPage{}, err
	}
	var series []seriesDTO
	if err := json.Unmarshal(pg.Results, &series); err != nil {
		return source.MangasPage{}, err
	}
	mangas := make([]source.SManga, len(series))
	for i, s2 := range series {
		mangas[i] = s.toSManga(s2)
	}
	return source.MangasPage{Mangas: mangas, HasNextPage: !pg.Last}, nil
}

func (s *Source) GetSearchManga(page int, query string, filters []source.Filter) (source.MangasPage, error) {
	u, _ := url.Parse(s.api() + "/series/")
	q := u.Query()
	q.Set("page", fmt.Sprintf("%d", page))
	q.Set("title", query)
	u.RawQuery = q.Encode()
	var pg paginator
	if err := s.getJSON(context.Background(), u.String(), &pg); err != nil {
		return source.MangasPage{}, err
	}
	var series []seriesDTO
	if err := json.Unmarshal(pg.Results, &series); err != nil {
		return source.MangasPage{}, err
	}
	mangas := make([]source.SManga, len(series))
	for i, s2 := range series {
		mangas[i] = s.toSManga(s2)
	}
	return source.MangasPage{Mangas: mangas, HasNextPage: !pg.Last}, nil
}

func (s *Source) GetMangaDetails(manga source.SManga) (source.SManga, error) {
	slug := util.SlugFromURL(strings.TrimRight(manga.URL, "/"))
	var d seriesDTO
	if err := s.getJSON(context.Background(), s.api()+"/series/"+slug+"/", &d); err != nil {
		return manga, err
	}
	return s.toSManga(d), nil
}

func (s *Source) GetChapterList(manga source.SManga) ([]source.SChapter, error) {
	slug := util.SlugFromURL(strings.TrimRight(manga.URL, "/"))
	apiURL := fmt.Sprintf("%s/chapters/?series=%s&date_format=timestamp", s.api(), slug)
	var pg paginator
	if err := s.getJSON(context.Background(), apiURL, &pg); err != nil {
		return nil, err
	}
	var chapters []chapterDTO
	if err := json.Unmarshal(pg.Results, &chapters); err != nil {
		return nil, err
	}
	result := make([]source.SChapter, len(chapters))
	for i, ch := range chapters {
		name := fmt.Sprintf("Chapter %.1f", ch.Number)
		if ch.Title != "" {
			name += " - " + ch.Title
		}
		result[i] = source.SChapter{
			URL:        fmt.Sprintf("/api/v2/chapters/%d/", ch.ID),
			Name:       name,
			DateUpload: util.ParseAbsoluteDate(ch.Published, "2006-01-02T15:04:05Z"),
		}
	}
	return result, nil
}

func (s *Source) GetPageList(chapter source.SChapter) ([]source.Page, error) {
	chID := util.SlugFromURL(strings.TrimRight(chapter.URL, "/"))
	apiURL := fmt.Sprintf("%s/chapters/%s/pages/", s.api(), chID)
	var pages []pageDTO
	if err := s.getJSON(context.Background(), apiURL, &pages); err != nil {
		return nil, err
	}
	result := make([]source.Page, len(pages))
	for i, p := range pages {
		result[i] = source.Page{Index: p.Number, ImageURL: p.Image}
	}
	return result, nil
}

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