package realdebrid

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

func UnrestrictCheck(accessToken, link string) (*UnrestrictResponse, error) {
	data := url.Values{}
	data.Set("link", link)

	req, err := http.NewRequest("POST", "https://api.real-debrid.com/rest/1.0/unrestrict/check", bytes.NewBufferString(data.Encode()))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP error: %s", resp.Status)
	}

	var response UnrestrictResponse
	err = json.Unmarshal(body, &response)
	if err != nil {
		return nil, err
	}

	return &response, nil
}

func UnrestrictLink(accessToken, link string) (*UnrestrictResponse, error) {
	data := url.Values{}
	data.Set("link", link)

	req, err := http.NewRequest("POST", "https://api.real-debrid.com/rest/1.0/unrestrict/link", bytes.NewBufferString(data.Encode()))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Authorization", "Bearer "+accessToken)
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP error: %s", resp.Status)
	}

	var response UnrestrictResponse
	err = json.Unmarshal(body, &response)
	if err != nil {
		return nil, err
	}

	return &response, nil
}

func GetTorrents(accessToken string) ([]Torrent, error) {
	baseURL := "https://api.real-debrid.com/rest/1.0/torrents"
	var allTorrents []Torrent
	page := 1
	limit := 100

	for {
		params := url.Values{}
		params.Set("page", fmt.Sprintf("%d", page))
		params.Set("limit", fmt.Sprintf("%d", limit))

		reqURL := baseURL + "?" + params.Encode()

		req, err := http.NewRequest("GET", reqURL, nil)
		if err != nil {
			return nil, err
		}

		req.Header.Set("Authorization", "Bearer "+accessToken)

		client := &http.Client{}
		resp, err := client.Do(req)
		if err != nil {
			return nil, err
		}
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusOK {
			return nil, fmt.Errorf("HTTP error: %s", resp.Status)
		}

		var torrents []Torrent
		decoder := json.NewDecoder(resp.Body)
		err = decoder.Decode(&torrents)
		if err != nil {
			return nil, err
		}

		allTorrents = append(allTorrents, torrents...)

		totalCountHeader := "100" // resp.Header.Get("x-total-count")
		totalCount, err := strconv.Atoi(totalCountHeader)
		if err != nil {
			break
		}

		if len(torrents) < limit || len(allTorrents) >= totalCount {
			break
		}

		page++
	}

	return deduplicateTorrents(allTorrents), nil
}

func GetTorrentInfo(accessToken, id string) (*Torrent, error) {
	url := "https://api.real-debrid.com/rest/1.0/torrents/info/" + id

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

	req.Header.Set("Authorization", "Bearer "+accessToken)

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP error: %s", resp.Status)
	}

	var response Torrent
	err = json.Unmarshal(body, &response)
	if err != nil {
		return nil, err
	}

	return &response, nil
}

func deduplicateTorrents(torrents []Torrent) []Torrent {
	mappedTorrents := make(map[string]Torrent)

	for _, t := range torrents {
		torrentName := t.Filename
		if existing, ok := mappedTorrents[torrentName]; ok {
			if existing.Hash == t.Hash {
				// If hash is the same, combine the links
				existing.ID += "," + t.ID
				// existing.Links = append(existing.Links, t.Links...)
				for _, link := range t.Links {
					existing.Links = appendIfNotExists(existing.Links, link)
				}
				existing.Bytes += t.Bytes
				existing.Added = moreRecent(existing.Added, t.Added)
				mappedTorrents[torrentName] = existing
			} else {
				// If hash is different, delete old entry and create two new entries
				delete(mappedTorrents, torrentName)
				newKey1 := fmt.Sprintf("%s - %s", torrentName, t.Hash[:4])
				mappedTorrents[newKey1] = t
				newKey2 := fmt.Sprintf("%s - %s", existing.Filename, existing.Hash[:4])
				mappedTorrents[newKey2] = existing
			}
		} else {
			mappedTorrents[torrentName] = t
		}
	}

	// Convert the map back to a slice
	deduplicated := make([]Torrent, 0, len(mappedTorrents))
	for _, value := range mappedTorrents {
		deduplicated = append(deduplicated, value)
	}

	return deduplicated
}

func contains(slice []string, str string) bool {
	for _, v := range slice {
		if v == str {
			return true
		}
	}
	return false
}

func appendIfNotExists(slice []string, str string) []string {
	if !contains(slice, str) {
		slice = append(slice, str)
	}
	return slice
}

func moreRecent(time1, time2 string) string {
	tTime1, err1 := time.Parse(time.RFC3339, time1)
	tTime2, err2 := time.Parse(time.RFC3339, time2)
	if err1 != nil || err2 != nil {
		return time1
	}
	if tTime2.After(tTime1) {
		time1 = time2
	}
	return time1
}