package edgar

import (
	"log"
	"time"

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

type Poller struct {
	db     *db.DB
	client *Client
	ticker *time.Ticker
	done   chan struct{}
	lastRun time.Time
}

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

func (p *Poller) Start() {
	p.ticker = time.NewTicker(6 * time.Hour)
	go func() {
		if err := p.Sync(); err != nil {
			log.Printf("edgar poller: initial sync: %v", err)
		}
		for {
			select {
			case <-p.ticker.C:
				if err := p.Sync(); err != nil {
					log.Printf("edgar poller: sync: %v", err)
				}
			case <-p.done:
				return
			}
		}
	}()
}

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

// SyncTicker récupère les insider trades et les events 8-K pour un ticker spécifique.
func (p *Poller) SyncTicker(sym string) error {
	trades, err := p.client.RecentInsiderBuys(sym)
	if err != nil {
		return err
	}
	for _, t := range trades {
		p.insertTrade(t)
	}
	events, _ := p.client.Recent8KEvents(sym)
	for _, e := range events {
		p.insertEvent(e)
	}
	return nil
}

// HasRecentCEOChange retourne true si un 8-K Item 5.02 a été déposé dans les N derniers jours.
func (p *Poller) HasRecentCEOChange(ticker string, days int) bool {
	cutoff := time.Now().AddDate(0, 0, -days).Format("2006-01-02")
	var count int
	p.db.QueryRow(`
		SELECT COUNT(*) FROM company_events
		WHERE ticker=? AND event_type='ceo_change' AND filing_date >= ?
	`, ticker, cutoff).Scan(&count)
	return count > 0
}

func (p *Poller) Sync() error {
	tickers, err := p.watchlistTickers()
	if err != nil {
		return err
	}
	if len(tickers) == 0 {
		return nil
	}

	log.Printf("edgar: scanning %d tickers for insider trades…", len(tickers))
	total := 0

	for _, sym := range tickers {
		trades, err := p.client.RecentInsiderBuys(sym)
		if err != nil {
			log.Printf("edgar: %s: %v", sym, err)
		} else {
			for _, t := range trades {
				if p.insertTrade(t) {
					total++
				}
			}
		}
		events, _ := p.client.Recent8KEvents(sym)
		for _, e := range events {
			p.insertEvent(e)
		}
		time.Sleep(500 * time.Millisecond) // respecter le rate limit EDGAR
	}

	p.lastRun = time.Now()
	if total > 0 {
		log.Printf("edgar: sync done — %d nouveaux insider trades", total)
	}
	return nil
}

func (p *Poller) watchlistTickers() ([]string, error) {
	rows, err := p.db.Query(`SELECT ticker FROM watchlist WHERE active=1`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var tickers []string
	for rows.Next() {
		var t string
		if err := rows.Scan(&t); err != nil {
			return nil, err
		}
		tickers = append(tickers, t)
	}
	return tickers, nil
}

func (p *Poller) insertEvent(e CompanyEvent) {
	p.db.Exec(`
		INSERT OR IGNORE INTO company_events
			(ticker, event_type, title, accession_no, filing_date, filing_url)
		VALUES (?, ?, ?, ?, ?, ?)
	`, e.Ticker, e.EventType, e.Title, e.AccessionNo, e.FilingDate, e.FilingURL)
}

func (p *Poller) insertTrade(t InsiderTrade) bool {
	res, err := p.db.Exec(`
		INSERT OR IGNORE INTO insider_trades
			(ticker, insider_name, insider_title, transaction_code,
			 shares, price, total_value, transaction_date, accession_no, filing_url)
		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
	`, t.Ticker, t.InsiderName, t.InsiderTitle, t.TransactionCode,
		t.Shares, t.PricePerShare, t.TotalValue, t.TransactionDate,
		t.AccessionNo, t.FilingURL)
	if err != nil {
		return false
	}
	n, _ := res.RowsAffected()
	return n > 0
}