package laosiji

import (
	"context"
	"sync"
	"time"
)

const SystemDomainsPath = "/lsjapi/system/domains"

type SystemDomains struct {
	ImgFreeCdn     string `json:"img_free_cdn"`
	ImgVipCdn      string `json:"img_vip_cdn"`
	ImgCnCdn       string `json:"img_cn_cdn"`
	ImgSourceCdn   string `json:"img_source_cdn"`
	MovieFreeCdn   string `json:"movie_free_cdn"`
	MovieVipCdn    string `json:"movie_vip_cdn"`
	MovieCnCdn     string `json:"movie_cn_cdn"`
	MovieSourceCdn string `json:"movie_source_cdn"`
	UploadURL      string `json:"upload_url"`
	MediaDir       string `json:"media_dir"`
	UploadKey      string `json:"upload_key"`
	UserID         string `json:"user_id"`
}

type Domains struct {
	client *Client

	mu        sync.RWMutex
	cur       *SystemDomains
	fetchedAt time.Time
}

func NewDomains(client *Client) *Domains {
	return &Domains{client: client}
}

func (d *Domains) Refresh(ctx context.Context) (*SystemDomains, error) {
	var sd SystemDomains
	if err := d.client.Call(ctx, SystemDomainsPath, map[string]string{}, &sd); err != nil {
		return nil, err
	}
	d.mu.Lock()
	d.cur = &sd
	d.fetchedAt = time.Now()
	d.mu.Unlock()
	return &sd, nil
}

func (d *Domains) Get(ctx context.Context) (*SystemDomains, error) {
	d.mu.RLock()
	cur := d.cur
	d.mu.RUnlock()
	if cur != nil {
		return cur, nil
	}
	return d.Refresh(ctx)
}

func (d *Domains) StartAutoRefresh(interval time.Duration) (stop func()) {
	done := make(chan struct{})
	go func() {
		t := time.NewTicker(interval)
		defer t.Stop()
		for {
			select {
			case <-done:
				return
			case <-t.C:
				ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
				_, _ = d.Refresh(ctx)
				cancel()
			}
		}
	}()
	return func() { close(done) }
}