package main

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

type OAuthToken struct {
	AccessToken string `json:"access_token"`
	ExpiresIn   int    `json:"expires_in"`
	TokenType   string `json:"token_type"`
	AcquiredAt  time.Time
}

type TwitchResp struct {
	Data []struct {
		ID        string `json:"id"`
		Title     string `json:"title"`
		StartedAt string `json:"started_at"`
	} `json:"data"`
}

var httpClient = &http.Client{Timeout: 15 * time.Second}
var oauthToken OAuthToken
var oauthMu sync.Mutex

func (t OAuthToken) Expired() bool {
	return time.Since(t.AcquiredAt) > time.Duration(t.ExpiresIn-120)*time.Second
}

func refreshToken(ctx context.Context, cfg *Config) error {
	oauthMu.Lock()
	defer oauthMu.Unlock()

	if oauthToken.AccessToken != "" && !oauthToken.Expired() {
		return nil
	}

	logDebug("fetching oauth token")
	endpoint := "https://id.twitch.tv/oauth2/token"

	data := url.Values{}
	data.Set("client_id", cfg.AppID)
	data.Set("client_secret", cfg.AppSecret)
	data.Set("grant_type", "client_credentials")

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, strings.NewReader(data.Encode()))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

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

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	if resp.StatusCode != http.StatusOK {
		return fmt.Errorf("token endpoint returned %d: %s", resp.StatusCode, string(body))
	}

	var tok OAuthToken
	if err := json.Unmarshal(body, &tok); err != nil {
		return err
	}

	tok.AcquiredAt = time.Now()
	oauthToken = tok
	logDebug("obtained oauth token, expires in %ds", oauthToken.ExpiresIn)
	return nil
}

// NOTE: the endpoint has the ability to query for multiple streams at a time
// this is currently not being done, but could be more correct
func isLive(ctx context.Context, cfg *Config, channel string) (bool, StreamInfo, error) {
	if err := refreshToken(ctx, cfg); err != nil {
		return false, StreamInfo{}, err
	}

	oauthMu.Lock()
	token := oauthToken.AccessToken
	oauthMu.Unlock()

	q := url.Values{"user_login": {channel}}
	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
		"https://api.twitch.tv/helix/streams?"+q.Encode(), nil)
	if err != nil {
		return false, StreamInfo{}, err
	}
	req.Header.Set("Client-ID", cfg.AppID)
	req.Header.Set("Authorization", "Bearer "+token)

	resp, err := httpClient.Do(req)
	if err != nil {
		return false, StreamInfo{}, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		b, _ := io.ReadAll(resp.Body)
		return false, StreamInfo{}, fmt.Errorf("twitch API status %d: %s", resp.StatusCode, b)
	}

	var tr TwitchResp
	if err := json.NewDecoder(resp.Body).Decode(&tr); err != nil {
		return false, StreamInfo{}, err
	}

	if len(tr.Data) == 0 {
		return false, StreamInfo{}, nil // stream is not live
	}

	startedAt, err := time.Parse(time.RFC3339, tr.Data[0].StartedAt)
	if err != nil {
		return false, StreamInfo{}, err
	}

	return true, StreamInfo{
		Channel:   channel,
		Title:     tr.Data[0].Title,
		StreamID:  tr.Data[0].ID,
		StartedAt: startedAt,
	}, nil
}
func probeCDNs(ctx context.Context, cdns []string, path string, n int) []string {
	client := &http.Client{Timeout: 5 * time.Second}
	var out []string
	for _, cdn := range cdns {
		if len(out) >= n || ctx.Err() != nil {
			break
		}
		u := "https://" + cdn + "/" + path
		req, err := http.NewRequestWithContext(ctx, http.MethodHead, u, nil)
		if err != nil {
			continue
		}
		resp, err := client.Do(req)
		if err != nil {
			continue
		}
		resp.Body.Close()
		if resp.StatusCode == http.StatusOK {
			out = append(out, u)
		}
	}
	return out
}
