package service

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"sync"
	"time"

	"git.sundynix.cn/Blizzard/Veyra/internal/apperror"
	"git.sundynix.cn/Blizzard/Veyra/internal/model"
	"github.com/google/uuid"
	"go.uber.org/zap"
)

type ScreeningRepository interface {
	Targets(context.Context, model.ProviderConfig) ([]model.ScreeningTarget, error)
	Record(context.Context, model.ScreeningTarget, model.StrategyScreening, *model.CandidateDraftInput) error
	List(context.Context) ([]model.StrategyScreening, error)
	Detail(context.Context, string) (model.StrategyScreening, error)
}
type ScreeningService struct {
	repo        ScreeningRepository
	market      *MarketService
	development bool
	cursor      int
	mu          sync.Mutex
	wake        chan struct{}
	state       model.ScreeningWorkerState
}

func NewScreeningService(repo ScreeningRepository, market *MarketService, development bool) *ScreeningService {
	return &ScreeningService{repo: repo, market: market, development: development, wake: make(chan struct{}, 1), state: model.ScreeningWorkerState{State: "IDLE", Message: "尚未运行"}}
}
func (s *ScreeningService) List(ctx context.Context, actor model.User) ([]model.StrategyScreening, error) {
	if actor.Role != "ADMIN" || actor.Status != "ACTIVE" {
		return nil, apperror.ErrForbidden
	}
	if s == nil || s.repo == nil || !s.development {
		return nil, apperror.ErrUnavailable
	}
	return s.repo.List(ctx)
}

func (s *ScreeningService) Detail(ctx context.Context, actor model.User, id string) (model.StrategyScreening, error) {
	if actor.Role != "ADMIN" || actor.Status != "ACTIVE" {
		return model.StrategyScreening{}, apperror.ErrForbidden
	}
	if s == nil || s.repo == nil || !s.development {
		return model.StrategyScreening{}, apperror.ErrUnavailable
	}
	if _, err := uuid.Parse(id); err != nil {
		return model.StrategyScreening{}, apperror.ErrInvalidInput
	}
	return s.repo.Detail(ctx, id)
}

func (s *ScreeningService) State(actor model.User) (model.ScreeningWorkerState, error) {
	if actor.Role != "ADMIN" || actor.Status != "ACTIVE" {
		return model.ScreeningWorkerState{}, apperror.ErrForbidden
	}
	if s == nil || s.repo == nil || s.market == nil || s.market.providers == nil || s.market.adapter == nil || !s.development {
		return model.ScreeningWorkerState{}, apperror.ErrUnavailable
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.state, nil
}
func (s *ScreeningService) RequestRun(actor model.User) (model.ScreeningWorkerState, error) {
	if _, err := s.State(actor); err != nil {
		return model.ScreeningWorkerState{}, err
	}
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.state.State == "RUNNING" || s.state.State == "QUEUED" {
		return s.state, nil
	}
	s.state = model.ScreeningWorkerState{State: "QUEUED", Message: "已排队，等待后台开始筛选"}
	select {
	case s.wake <- struct{}{}:
	default:
	}
	return s.state, nil
}

var screeningZone = time.FixedZone("Asia/Shanghai", 8*60*60)

// EvaluateScreening uses completed daily bars only. Re-fetching a historical quote
// never makes it fresh, and an unclosed session cannot generate a daily signal.
func EvaluateScreening(t model.ScreeningTarget, c model.ProviderConfig, h model.MarketHistory, now time.Time) (model.StrategyScreening, *model.CandidateDraftInput, error) {
	var result model.StrategyScreening
	p := t.Version.Parameters
	q := p.Screening
	i := t.Instrument
	if q == nil || model.ValidateScreening(q) != nil || p.ShortWindow < 2 || p.LongWindow <= p.ShortWindow || p.LongWindow > 200 || h.Symbol != i.Symbol || h.Exchange != i.Exchange || h.Source != c.MarketAdapter || h.SourceVersion != c.Version || h.Adjustment != "unadjusted" || i.SourceID != c.ID || i.SourceVersion != c.Version || i.ObservedAt.Before(now.Add(-24*time.Hour)) || i.ObservedAt.After(now.Add(time.Minute)) || i.ReceivedAt.Before(now.Add(-10*time.Minute)) || h.ReceivedAt.Before(now.Add(-10*time.Minute)) || h.ReceivedAt.After(now.Add(time.Minute)) {
		return result, nil, apperror.ErrUnavailable
	}
	day := i.ObservedAt.In(screeningZone).Format("2006-01-02")
	localNow := now.In(screeningZone)
	if day == localNow.Format("2006-01-02") && localNow.Hour() < 16 {
		return result, nil, apperror.ErrUnavailable
	}
	if len(h.Bars) < p.LongWindow+1 || h.Bars[len(h.Bars)-1].Date != day {
		return result, nil, apperror.ErrUnavailable
	}
	bars := append([]model.HistoricalBar(nil), h.Bars[len(h.Bars)-p.LongWindow-1:]...)
	closes := make([]int64, len(bars))
	previous := ""
	for j, b := range bars {
		d, e := time.Parse("2006-01-02", b.Date)
		o, e1 := model.ParseMoney(b.Open)
		hi, e2 := model.ParseMoney(b.High)
		lo, e3 := model.ParseMoney(b.Low)
		cl, e4 := model.ParseMoney(b.Close)
		if e != nil || d.Format("2006-01-02") != b.Date || b.Date <= previous || b.Date > day || e1 != nil || e2 != nil || e3 != nil || e4 != nil || lo <= 0 || hi < lo || o < lo || o > hi || cl < lo || cl > hi {
			return result, nil, apperror.ErrInvalidInput
		}
		closes[j] = cl
		previous = b.Date
	}
	sum := func(end, n int) int64 {
		var v int64
		for _, x := range closes[end-n : end] {
			v += x
		}
		return v
	}
	end := len(closes)
	prevShort, prevLong := sum(end-1, p.ShortWindow), sum(end-1, p.LongWindow)
	short, long := sum(end, p.ShortWindow), sum(end, p.LongWindow)
	signal := prevShort*int64(p.LongWindow) <= prevLong*int64(p.ShortWindow) && short*int64(p.LongWindow) > long*int64(p.ShortWindow)
	input, _ := json.Marshal(struct {
		Parameters model.StrategyParameters `json:"parameters"`
		Bars       []model.HistoricalBar    `json:"bars"`
	}{p, bars})
	hash := sha256.Sum256(input)
	result = model.StrategyScreening{StrategyVersionID: t.Version.ID, Symbol: i.Symbol, Exchange: i.Exchange, BarDate: day, SourceID: c.ID, SourceVersion: c.Version, SourceAdapter: c.MarketAdapter, ObservedAt: i.ObservedAt, ReceivedAt: h.ReceivedAt, InputHash: hex.EncodeToString(hash[:]), Input: input, Status: "NO_SIGNAL"}
	if !signal {
		return result, nil, nil
	}
	base := closes[end-1]
	low := base * (10000 - q.EntryBandBPS) / 10000
	high := (base*(10000+q.EntryBandBPS) + 9999) / 10000
	stop := base * (10000 - q.StopLossBPS) / 10000
	target := (base*(10000+q.TargetBPS) + 9999) / 10000
	draft := model.CandidateDraftInput{ObservedAt: i.ObservedAt, ValidUntil: now.Add(time.Duration(q.ValidHours) * time.Hour), Content: model.CandidateContent{
		Symbol: i.Symbol, Exchange: i.Exchange, Name: i.Name, StrategyCode: "trend_following", Title: i.Name + " · 日线均线交叉待审核",
		Thesis:          fmt.Sprintf("已完成日线 %s 出现 %d / %d 日均线上穿。策略 %s 修订 %d，仅为规则筛选结果，需人工核验后发布。", day, p.ShortWindow, p.LongWindow, t.StrategyName, t.Version.Revision),
		Evidence:        []model.CandidateEvidence{{SourceURL: c.HistoryBaseURL, Locator: fmt.Sprintf("%s:%s 日线 %s", i.Exchange, i.Symbol, day), Summary: fmt.Sprintf("来源 %s 配置版本 %d；未复权收盘价 %s；输入摘要 %s。参数与日线快照在筛选记录中保留。", c.MarketAdapter, c.Version, model.FormatMoney(base), result.InputHash)}},
		CounterEvidence: "公开数据可能缺失或延迟；未复权均线会受除权影响。此规则未核验公告、停复牌、涨跌停、流动性及策略有效性。",
		Invalidation:    "策略暂停或切换版本、候选过期或撤回后失效；复核价格区间及数据来源后方可发布。",
		ReferencePlan:   model.CandidateReferencePlan{EntryLow: model.FormatMoney(low), EntryHigh: model.FormatMoney(high), StopLoss: model.FormatMoney(stop), TargetPrice: model.FormatMoney(target)},
	}}
	if e := model.ValidateDraft(draft, now); e != nil {
		return result, nil, e
	}
	result.Status = "SIGNAL"
	return result, &draft, nil
}
func (s *ScreeningService) Process(ctx context.Context, logger *zap.Logger) (processErr error) {
	started := time.Now().UTC()
	s.mu.Lock()
	if s.state.State == "RUNNING" {
		s.mu.Unlock()
		return apperror.ErrConflict
	}
	s.state = model.ScreeningWorkerState{State: "RUNNING", StartedAt: &started, Message: "正在获取日线并计算信号"}
	s.mu.Unlock()
	defer func() {
		finished := time.Now().UTC()
		s.mu.Lock()
		defer s.mu.Unlock()
		s.state.FinishedAt = &finished
		if processErr != nil {
			s.state.State = "FAILED"
			s.state.Message = "筛选未完成，请检查行情源与后台日志"
		} else {
			s.state.State = "COMPLETED"
			s.state.Message = fmt.Sprintf("检查 %d 只，完成 %d 只，生成 %d 条待审核候选，跳过 %d 只，失败 %d 只", s.state.Targets, s.state.Completed, s.state.Generated, s.state.Skipped, s.state.Failed)
		}
	}()

	c, err := s.market.configuration(ctx)
	if err != nil {
		return err
	}
	targets, err := s.repo.Targets(ctx, c)
	if err != nil {
		return err
	}
	// Rotate across eligible targets so an unavailable feed cannot starve other strategies.
	if len(targets) == 0 {
		return nil
	}
	s.mu.Lock()
	start := s.cursor % len(targets)
	count := min(20, len(targets))
	s.state.Targets = count
	s.cursor = (start + count) % len(targets)
	s.mu.Unlock()
	for offset := 0; offset < count; offset++ {
		t := targets[(start+offset)%len(targets)]
		if ctx.Err() != nil {
			return ctx.Err()
		}
		now := time.Now().UTC()
		task, cancel := context.WithTimeout(ctx, 30*time.Second)
		h, e := s.market.adapter.History(task, c, t.Instrument.Symbol, t.Instrument.Exchange, now.AddDate(-3, 0, 0).Format("2006-01-02"), now.Format("2006-01-02"))
		if e == nil {
			var run model.StrategyScreening
			var draft *model.CandidateDraftInput
			run, draft, e = EvaluateScreening(t, c, h, time.Now().UTC())
			if e == nil {
				e = s.repo.Record(task, t, run, draft)
				if e == nil {
					s.mu.Lock()
					s.state.Completed++
					if draft != nil {
						s.state.Generated++
					}
					s.mu.Unlock()
				}
			}
		}
		cancel()
		if e != nil {
			s.mu.Lock()
			if errors.Is(e, apperror.ErrConflict) || errors.Is(e, apperror.ErrUnavailable) {
				s.state.Skipped++
			} else {
				s.state.Failed++
			}
			s.mu.Unlock()
		}
		if e != nil && !errors.Is(e, apperror.ErrConflict) && !errors.Is(e, apperror.ErrUnavailable) && ctx.Err() == nil {
			logger.Warn("strategy screening failed", zap.String("strategy_version_id", t.Version.ID), zap.String("symbol", t.Instrument.Symbol), zap.Error(e))
		}
	}
	return nil
}
func (s *ScreeningService) Run(ctx context.Context, logger *zap.Logger) {
	if s == nil || s.repo == nil || s.market == nil || s.market.adapter == nil || !s.development {
		return
	}
	for {
		if err := s.Process(ctx, logger); err != nil && !errors.Is(err, apperror.ErrUnavailable) && !errors.Is(err, apperror.ErrNotFound) && ctx.Err() == nil {
			logger.Warn("strategy screening worker failed", zap.Error(err))
		}
		select {
		case <-ctx.Done():
			return
		case <-s.wake:
		case <-time.After(5 * time.Minute):
		}
	}
}