package realdebrid

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"

	zurghttp "github.com/debridmediamanager/zurg/pkg/http"
	"github.com/debridmediamanager/zurg/pkg/logutil"
)

type RealDebrid struct {
	log    *logutil.Logger
	client *zurghttp.HTTPClient
}

func NewRealDebrid(client *zurghttp.HTTPClient, log *logutil.Logger) *RealDebrid {
	return &RealDebrid{
		log:    log,
		client: client,
	}
}

func (rd *RealDebrid) UnrestrictCheck(link string) (*Download, 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 {
		rd.log.Errorf("Error when creating a unrestrict check request: %v", err)
		return nil, err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the unrestrict check request: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		rd.log.Errorf("Error when reading the body of unrestrict check response: %v", err)
		return nil, err
	}

	var response Download
	err = json.Unmarshal(body, &response)
	if err != nil {
		rd.log.Errorf("Error when decoding unrestrict check JSON: %v", err)
		return nil, err
	}

	rd.log.Debugf("Link %s is streamable? %v", response.Streamable)
	return &response, nil
}

// GetTorrents returns all torrents, paginated
// if customLimit is 0, the default limit of 1000 is used
func (rd *RealDebrid) GetTorrents(customLimit int, active bool) ([]Torrent, int, error) {
	baseURL := "https://api.real-debrid.com/rest/1.0/torrents"
	var allTorrents []Torrent
	page := 1
	limit := customLimit
	if limit == 0 {
		limit = 1000
	}
	totalCount := 0

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

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

		req, err := http.NewRequest("GET", reqURL, nil)
		if err != nil {
			rd.log.Errorf("Error when creating a get torrents request: %v", err)
			return nil, 0, err
		}

		resp, err := rd.client.Do(req)
		if err != nil {
			rd.log.Errorf("Error when executing the get torrents request: %v", err)
			return nil, 0, err
		}
		defer resp.Body.Close()

		if resp.StatusCode == http.StatusNoContent {
			return allTorrents, 0, nil
		}

		// if status code is not 2xx, return erro

		var torrents []Torrent
		decoder := json.NewDecoder(resp.Body)
		err = decoder.Decode(&torrents)
		if err != nil {
			rd.log.Errorf("Error when decoding get torrents JSON: %v", err)
			return nil, 0, err
		}

		allTorrents = append(allTorrents, torrents...)

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

		if len(allTorrents) >= totalCount || (customLimit != 0 && customLimit <= len(allTorrents) && customLimit <= totalCount) {
			break
		}

		rd.log.Debugf("Got %d torrents (page %d), total count is %d", len(allTorrents), page, totalCount)

		page++
	}
	return allTorrents, totalCount, nil
}

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

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		rd.log.Errorf("Error when creating a get info request: %v", err)
		return nil, err
	}

	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the get info request: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		rd.log.Errorf("Error when reading the body of get info response: %v", err)
		return nil, err
	}

	var response TorrentInfo
	err = json.Unmarshal(body, &response)
	if err != nil {
		rd.log.Errorf("Error when : %v", err)
		return nil, err
	}

	rd.log.Debugf("Got info for torrent %s (progress=%d%%)", id, response.Progress)
	return &response, nil
}

// SelectTorrentFiles selects files of a torrent to start it.
func (rd *RealDebrid) SelectTorrentFiles(id string, files string) error {
	data := url.Values{}
	data.Set("files", files)

	reqURL := fmt.Sprintf("https://api.real-debrid.com/rest/1.0/torrents/selectFiles/%s", id)
	req, err := http.NewRequest("POST", reqURL, bytes.NewBufferString(data.Encode()))
	if err != nil {
		rd.log.Errorf("Error when creating a select files request: %v", err)
		return err
	}

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

	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the select files request: %v", err)
		return err
	}
	defer resp.Body.Close()

	rd.log.Debugf("Selected %d files and started the download for torrent id=%s", len(strings.Split(files, ",")), id)
	return nil
}

// DeleteTorrent deletes a torrent from the torrents list.
func (rd *RealDebrid) DeleteTorrent(id string) error {
	// Construct request URL
	reqURL := fmt.Sprintf("https://api.real-debrid.com/rest/1.0/torrents/delete/%s", id)
	req, err := http.NewRequest("DELETE", reqURL, nil)
	if err != nil {
		rd.log.Errorf("Error when creating a delete torrent request: %v", err)
		return err
	}

	// Send the request
	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the delete torrent request: %v", err)
		return err
	}
	defer resp.Body.Close()

	rd.log.Debugf("Deleted torrent with id=%s", id)
	return nil
}

// AddMagnetHash adds a magnet link to download.
func (rd *RealDebrid) AddMagnetHash(magnet string) (*MagnetResponse, error) {
	// Prepare request data
	data := url.Values{}
	data.Set("magnet", fmt.Sprintf("magnet:?xt=urn:btih:%s", magnet))

	// Construct request URL
	reqURL := "https://api.real-debrid.com/rest/1.0/torrents/addMagnet"
	req, err := http.NewRequest("POST", reqURL, bytes.NewBufferString(data.Encode()))
	if err != nil {
		rd.log.Errorf("Error when creating an add magnet request: %v", err)
		return nil, err
	}

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

	// Send the request
	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the add magnet request: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	var response MagnetResponse
	err = json.NewDecoder(resp.Body).Decode(&response)
	if err != nil {
		rd.log.Errorf("Error when decoding add magnet JSON: %v", err)
		return nil, err
	}

	rd.log.Debugf("Added magnet %s with id=%s", magnet, response.ID)
	return &response, nil
}

// GetActiveTorrentCount gets the number of currently active torrents and the current maximum limit.
func (rd *RealDebrid) GetActiveTorrentCount() (*ActiveTorrentCountResponse, error) {
	// Construct request URL
	reqURL := "https://api.real-debrid.com/rest/1.0/torrents/activeCount"
	req, err := http.NewRequest("GET", reqURL, nil)
	if err != nil {
		rd.log.Errorf("Error when creating a active torrents request: %v", err)
		return nil, err
	}

	// Send the request
	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the active torrents request: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	var response ActiveTorrentCountResponse
	err = json.NewDecoder(resp.Body).Decode(&response)
	if err != nil {
		rd.log.Errorf("Error when decoding active torrents JSON: %v", err)
		return nil, err
	}
	return &response, nil
}

func (rd *RealDebrid) UnrestrictLink(link string, checkFirstByte bool) (*Download, 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 {
		rd.log.Errorf("Error when creating a unrestrict link request: %v", err)
		return nil, err
	}

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

	// at this point, any errors mean that the link has expired and we need to repair it
	resp, err := rd.client.Do(req)
	if err != nil {
		// rd.log.Errorf("Error when executing the unrestrict link request: %v", err)
		return nil, fmt.Errorf("unrestrict link request failed: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		rd.log.Errorf("Unrestrict link request returned status code %d for link %s", resp.StatusCode, link)
		// return nil, fmt.Errorf("unrestrict link request returned status code %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		// rd.log.Errorf("Error when reading the body of unrestrict link response: %v", err)
		return nil, fmt.Errorf("unreadable body: %v", err)
	}

	var response Download
	err = json.Unmarshal(body, &response)
	if err != nil {
		// rd.log.Errorf("Error when decoding unrestrict link JSON: %v", err)
		return nil, fmt.Errorf("undecodable response: %v", err)
	}

	if checkFirstByte && !rd.client.CanFetchFirstByte(response.Download) {
		return nil, fmt.Errorf("can't fetch first byte")
	}

	// rd.log.Debugf("Unrestricted link %s into %s", link, response.Download)
	return &response, nil
}

// GetDownloads returns all torrents, paginated
func (rd *RealDebrid) GetDownloads(page, offset int) ([]Download, int, error) {
	baseURL := "https://api.real-debrid.com/rest/1.0/downloads"
	var allDownloads []Download
	limit := 1000
	totalCount := 0

	params := url.Values{}
	params.Set("page", fmt.Sprintf("%d", page))
	params.Set("offset", fmt.Sprintf("%d", offset))
	params.Set("limit", fmt.Sprintf("%d", limit))
	// params.Set("filter", "active")

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

	req, err := http.NewRequest("GET", reqURL, nil)
	if err != nil {
		rd.log.Errorf("Error when creating a get downloads request: %v", err)
		return nil, 0, err
	}

	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the get downloads request: %v", err)
		return nil, 0, err
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNoContent {
		return allDownloads, 0, nil
	}

	// if status code is not 2xx, return erro

	var downloads []Download
	decoder := json.NewDecoder(resp.Body)
	err = decoder.Decode(&downloads)
	if err != nil {
		rd.log.Errorf("Error when decoding get downloads JSON: %v", err)
		return nil, 0, err
	}

	allDownloads = append(allDownloads, downloads...)

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

	rd.log.Debugf("Got %d downloads (page %d), total count is %d", len(allDownloads)+offset, page, totalCount)
	return allDownloads, totalCount, nil
}

// GetUserInformation gets the current user information.
func (rd *RealDebrid) GetUserInformation() (*User, error) {
	// Construct request URL
	reqURL := "https://api.real-debrid.com/rest/1.0/user"
	req, err := http.NewRequest("GET", reqURL, nil)
	if err != nil {
		rd.log.Errorf("Error when creating a user information request: %v", err)
		return nil, err
	}

	// Send the request
	resp, err := rd.client.Do(req)
	if err != nil {
		rd.log.Errorf("Error when executing the user information request: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	// Decode the JSON response into the User struct
	var user User
	err = json.NewDecoder(resp.Body).Decode(&user)
	if err != nil {
		rd.log.Errorf("Error when decoding user information JSON: %v", err)
		return nil, err
	}

	return &user, nil
}

// AvailabilityCheck checks the instant availability of torrents
func (rd *RealDebrid) AvailabilityCheck(hashes []string) (AvailabilityResponse, error) {
	if len(hashes) == 0 {
		return nil, fmt.Errorf("no hashes provided")
	}

	baseURL := "https://api.real-debrid.com/rest/1.0"
	url := fmt.Sprintf("%s/torrents/instantAvailability/%s", baseURL, strings.Join(hashes, "/"))
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, err
	}

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

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("error, got response status code %d", resp.StatusCode)
	}

	var response AvailabilityResponse
	err = json.NewDecoder(resp.Body).Decode(&response)
	if err != nil {
		return nil, err
	}

	return response, nil
}