StockRadar/internal/etoro/poller.go

package etoro

import (
	"fmt"
	"log"
	"sync"
	"time"

	"git.rouggy.com/rouggy/stockradar/internal/db"
)

type SyncStatus struct {
	Syncing   bool      `json:"syncing"`
	Progress  int       `json:"progress"`
	Total     int       `json:"total"`
	Count     int       `json:"count"`
	LastSync  time.Time `json:"last_sync"`
	LastError string    `json:"last_error,omitempty"`
}

type Poller struct {
	db      *db.DB
	client  *Client
	getKeys func() (apiKey, userKey string, err error)
	ticker  *time.Ticker
	done    chan struct{}

	mu        sync.Mutex
	syncing   bool
	progress  int
	total     int
	lastSync  time.Time
	lastError string
}

func NewPoller(database *db.DB, getKeys func() (string, string, error)) *Poller {
	return &Poller{
		db:      database,
		client:  New(),
		getKeys: getKeys,
		done:    make(chan struct{}),
	}
}

func (p *Poller) Start() {
	p.ticker = time.NewTicker(24 * time.Hour)
	go func() {
		// Sync uniquement si la DB est vide
		if p.dbCount() == 0 {
			if err := p.Sync(); err != nil {
				log.Printf("etoro poller: initial sync: %v", err)
			}
		} else {
			log.Printf("etoro: %d instruments déjà en DB, sync ignorée au démarrage", p.dbCount())
		}
		for {
			select {
			case <-p.ticker.C:
				if err := p.Sync(); err != nil {
					log.Printf("etoro poller: sync: %v", err)
				}
			case <-p.done:
				return
			}
		}
	}()
}

func (p *Poller) Stop() {
	if p.ticker != nil {
		p.ticker.Stop()
	}
	close(p.done)
}

func (p *Poller) Status() SyncStatus {
	p.mu.Lock()
	defer p.mu.Unlock()
	return SyncStatus{
		Syncing:   p.syncing,
		Progress:  p.progress,
		Total:     p.total,
		Count:     p.dbCount(),
		LastSync:  p.lastSync,
		LastError: p.lastError,
	}
}

func (p *Poller) Sync() error {
	p.mu.Lock()
	if p.syncing {
		p.mu.Unlock()
		return nil // déjà en cours
	}
	p.syncing = true
	p.progress = 0
	p.total = 0
	p.lastError = ""
	p.mu.Unlock()

	defer func() {
		p.mu.Lock()
		p.syncing = false
		p.lastSync = time.Now()
		p.mu.Unlock()
	}()

	apiKey, userKey, err := p.getKeys()
	if err != nil || apiKey == "" || userKey == "" {
		p.mu.Lock()
		p.lastError = "clés API eToro non configurées (Settings)"
		p.mu.Unlock()
		return fmt.Errorf("etoro: clés manquantes")
	}
	p.client.SetKeys(apiKey, userKey)

	log.Println("etoro: fetching instruments…")

	const pageSize = 500
	inserted := 0
	fetched := 0

	for page := 1; ; page++ {
		sr, err := p.client.fetchPage(5, pageSize, page)
		if err != nil {
			p.mu.Lock()
			p.lastError = err.Error()
			p.mu.Unlock()
			log.Printf("etoro: fetch error page %d: %v", page, err)
			return err
		}

		// On connaît le total dès la première page
		if page == 1 {
			p.mu.Lock()
			p.total = sr.TotalItems
			p.mu.Unlock()
			log.Printf("etoro: %d stocks à synchroniser", sr.TotalItems)
		}

		for _, s := range sr.Items {
			if s.IsHidden || s.IsDelisted || !s.IsBuyEnabled {
				continue
			}
			_, err := p.db.Exec(`
				INSERT INTO instruments (instrument_id, ticker, name, exchange_id, asset_class_id, synced_at)
				VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
				ON CONFLICT(instrument_id) DO UPDATE SET
					ticker      = excluded.ticker,
					name        = excluded.name,
					exchange_id = excluded.exchange_id,
					synced_at   = CURRENT_TIMESTAMP
			`, s.InstrumentID, s.SymbolFull, s.InstrumentDisplayName,
				s.ExchangeID, s.AssetClassID)
			if err == nil {
				inserted++
			}
			fetched++
		}

		p.mu.Lock()
		p.progress = fetched
		p.mu.Unlock()
		log.Printf("etoro: page %d — %d/%d traités", page, fetched, sr.TotalItems)

		if page*pageSize >= sr.TotalItems {
			break
		}
	}

	log.Printf("etoro: sync terminée — %d instruments en DB", inserted)
	return nil
}

func (p *Poller) dbCount() int {
	var n int
	p.db.QueryRow(`SELECT COUNT(*) FROM instruments`).Scan(&n)
	return n
}

// IsEtoro vérifie si un ticker est dans l'univers eToro.
func IsEtoro(database *db.DB, ticker string) bool {
	var count int
	database.QueryRow(`SELECT COUNT(*) FROM instruments WHERE ticker = ?`, ticker).Scan(&count)
	return count > 0
}