package backtest

import (
	"context"
	"testing"
	"time"

	"git.toki-labs.com/toki/alt/packages/domain/backtest"
	"git.toki-labs.com/toki/alt/packages/domain/market"
)

type mockBarSource struct {
	bars    []market.Bar
	gotSpec backtest.RunSpec
}

func (m *mockBarSource) GetBarsForRun(ctx context.Context, spec backtest.RunSpec) ([]market.Bar, error) {
	m.gotSpec = spec
	return m.bars, nil
}

type mockStrategy struct {
	decideCalls []backtest.StrategyInput
}

func (m *mockStrategy) ID() backtest.StrategyID {
	return "test-strategy"
}

func (m *mockStrategy) Decide(input backtest.StrategyInput) ([]backtest.OrderIntent, error) {
	m.decideCalls = append(m.decideCalls, input)

	// Buy 2 units of the instrument on the first bar
	if len(m.decideCalls) == 1 {
		return []backtest.OrderIntent{
			{
				InstrumentID: input.Bar.InstrumentID,
				Side:         backtest.OrderSideBuy,
				Quantity:     market.Quantity{Amount: market.Decimal{Value: "2"}},
			},
		}, nil
	}
	return nil, nil
}

type mockStrategyPort struct {
	strategy backtest.Strategy
}

func (m *mockStrategyPort) GetStrategy(ctx context.Context, id backtest.StrategyID) (backtest.Strategy, error) {
	return m.strategy, nil
}

// TestEngineFillsOrdersOnNextMatchingInstrumentBar proves the engine holds
// strategy orders as pending and executes them on the next available bar for
// the same instrument using FillOrderOnBar (bar.Open for market orders).
func TestEngineFillsOrdersOnNextMatchingInstrumentBar(t *testing.T) {
	bar1 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "990"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "980"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
	}
	bar2 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1010"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1100"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1100"}},
	}

	barSource := &mockBarSource{bars: []market.Bar{bar2, bar1}} // unsorted
	strat := &mockStrategy{}
	engine := NewEngine(barSource, &mockStrategyPort{strategy: strat}, nil)

	run := backtest.Run{
		ID: "run-next-bar",
		Spec: backtest.RunSpec{
			StrategyID: "test-strategy",
			Market:     market.MarketKR,
			Timeframe:  market.TimeframeDaily,
			From:       time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
			To:         time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		},
	}

	err := engine.Execute(context.Background(), run)
	if err != nil {
		t.Fatalf("Engine execution failed: %v", err)
	}

	if len(strat.decideCalls) != 2 {
		t.Fatalf("expected 2 strategy Decide calls, got %d", len(strat.decideCalls))
	}

	// First call: bar1 (May 1). Strategy returns buy order for 2 units.
	// Cash should be 10000000 (initial), position 0.
	firstCall := strat.decideCalls[0]
	if !firstCall.Bar.Timestamp.Equal(bar1.Timestamp) {
		t.Errorf("expected first bar to be May 1, got %s", firstCall.Bar.Timestamp)
	}
	if firstCall.Portfolio.Cash.Amount.Value != "10000000" {
		t.Errorf("expected starting cash 10000000, got %s", firstCall.Portfolio.Cash.Amount.Value)
	}

	// Second call: bar2 (May 2). Strategy returns nil (no orders).
	// The buy from bar1 should have been filled on bar2 at bar2.Open = 1010.
	secondCall := strat.decideCalls[1]
	if !secondCall.Bar.Timestamp.Equal(bar2.Timestamp) {
		t.Errorf("expected second bar to be May 2, got %s", secondCall.Bar.Timestamp)
	}

	// After buy: cash = 10000000 - 2*1010 = 9997980, position = 2
	if secondCall.Portfolio.Cash.Amount.Value != "9997980" {
		t.Errorf("expected cash after buy at 1010 to be 9997980, got %s", secondCall.Portfolio.Cash.Amount.Value)
	}
	pos, ok := secondCall.Portfolio.Position(market.InstrumentID("KRX:005930"))
	if !ok {
		t.Fatal("expected position in second call portfolio")
	}
	if pos.Quantity.Amount.Value != "2" {
		t.Errorf("expected position quantity 2, got %s", pos.Quantity.Amount.Value)
	}
}

// TestEnginePassesRunSpecToBarSource proves the engine forwards the whole RunSpec
// (including the input selector) to the bar source instead of dropping selection
// at the engine boundary.
func TestEnginePassesRunSpecToBarSource(t *testing.T) {
	barSource := &mockBarSource{}
	strategyPort := &mockStrategyPort{strategy: &mockStrategy{}}
	engine := NewEngine(barSource, strategyPort, nil)

	run := backtest.Run{
		ID: "run-selector",
		Spec: backtest.RunSpec{
			StrategyID: "test-strategy",
			Market:     market.MarketKR,
			Timeframe:  market.TimeframeDaily,
			From:       time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
			To:         time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
			Selector: backtest.InputSelector{
				InstrumentIDs: []market.InstrumentID{"KRX:005930"},
				Symbols:       []string{"005930"},
			},
		},
	}

	if err := engine.Execute(context.Background(), run); err != nil {
		t.Fatalf("Engine execution failed: %v", err)
	}

	if len(barSource.gotSpec.Selector.InstrumentIDs) != 1 ||
		barSource.gotSpec.Selector.InstrumentIDs[0] != "KRX:005930" {
		t.Errorf("selector instrument ids not forwarded: %+v", barSource.gotSpec.Selector)
	}
	if len(barSource.gotSpec.Selector.Symbols) != 1 || barSource.gotSpec.Selector.Symbols[0] != "005930" {
		t.Errorf("selector symbols not forwarded: %+v", barSource.gotSpec.Selector)
	}
}

// TestEngineOrdersEqualTimestampBarsByInstrumentID verifies that when multiple
// bars share the same timestamp the engine passes them to strategy.Decide in
// ascending instrument id order, matching the StorageBarSource sort contract.
func TestEngineOrdersEqualTimestampBarsByInstrumentID(t *testing.T) {
	sameTime := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
	barA := market.Bar{
		InstrumentID: market.InstrumentID("KRX:000660"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    sameTime,
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "80000"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "80000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "79000"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "81000"}},
	}
	barB := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    sameTime,
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "990"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1010"}},
	}

	// Provide bars in reverse instrument-id order to prove the engine sorts them.
	barSource := &mockBarSource{bars: []market.Bar{barB, barA}}
	strat := &multiInstrumentBuyStrategy{}
	engine := NewEngine(barSource, &mockStrategyPort{strategy: strat}, nil)

	run := backtest.Run{
		ID: "run-tie",
		Spec: backtest.RunSpec{
			StrategyID: "test-strategy",
			Market:     market.MarketKR,
			Timeframe:  market.TimeframeDaily,
			From:       sameTime,
			To:         sameTime,
		},
	}
	if err := engine.Execute(context.Background(), run); err != nil {
		t.Fatalf("Engine execution failed: %v", err)
	}
	if len(strat.decideCalls) != 2 {
		t.Fatalf("expected 2 Decide calls, got %d", len(strat.decideCalls))
	}
	if strat.decideCalls[0].Bar.InstrumentID != barA.InstrumentID {
		t.Errorf("first Decide call: got instrument %q, want %q", strat.decideCalls[0].Bar.InstrumentID, barA.InstrumentID)
	}
	if strat.decideCalls[1].Bar.InstrumentID != barB.InstrumentID {
		t.Errorf("second Decide call: got instrument %q, want %q", strat.decideCalls[1].Bar.InstrumentID, barB.InstrumentID)
	}
}

// multiInstrumentBuyStrategy buys on every bar.
type multiInstrumentBuyStrategy struct {
	decideCalls []backtest.StrategyInput
}

func (s *multiInstrumentBuyStrategy) ID() backtest.StrategyID {
	return "multi-buy"
}

func (s *multiInstrumentBuyStrategy) Decide(input backtest.StrategyInput) ([]backtest.OrderIntent, error) {
	s.decideCalls = append(s.decideCalls, input)
	return []backtest.OrderIntent{{
		InstrumentID: input.Bar.InstrumentID,
		Side:         backtest.OrderSideBuy,
		Quantity:     market.Quantity{Amount: market.Decimal{Value: "1"}},
	}}, nil
}

// TestEngineCarriesUncrossedLimitOrderToLaterMatchingBar proves that a limit order
// whose price was not crossed on the first matching bar is kept pending and fills
// on a later bar where the price condition is met.
func TestEngineCarriesUncrossedLimitOrderToLaterMatchingBar(t *testing.T) {
	bar1 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "990"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1010"}},
	}
	// bar2: low=950 > limit=940, so limit buy does NOT cross
	bar2 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1050"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "950"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1060"}},
	}
	// bar3: low=930 <= limit=940, so limit buy DOES cross
	bar3 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 3, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "950"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "900"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "930"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "970"}},
	}

	limitBuyStrategy := &limitBuyStrategy{limitPrice: market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "940"}}}
	store := newInMemoryResultStore()
	engine := NewEngine(&mockBarSource{bars: []market.Bar{bar1, bar2, bar3}}, &mockStrategyPort{strategy: limitBuyStrategy}, store)

	run := backtest.Run{
		ID: "run-limit-carry",
		Spec: backtest.RunSpec{
			StrategyID: "limit-buy-strategy",
			Market:     market.MarketKR,
			Timeframe:  market.TimeframeDaily,
			From:       time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
			To:         time.Date(2026, 5, 3, 0, 0, 0, 0, time.UTC),
		},
	}

	if err := engine.Execute(context.Background(), run); err != nil {
		t.Fatalf("Engine execution failed: %v", err)
	}

	result, err := store.GetResult(context.Background(), run.ID)
	if err != nil {
		t.Fatalf("failed to get result: %v", err)
	}

	// bar1: strategy returns limit buy @ 940 on first bar.
	// bar2: low=950 > limit=940, limit buy @ 940 does NOT fill.
	// bar3: low=930 <= limit=940, limit buy @ 940 DOES fill.
	// Expected: 1 trade, filled at bar3.
	if len(result.Trades) != 1 {
		t.Fatalf("expected 1 trade, got %d", len(result.Trades))
	}
	if len(result.Trades) > 0 {
		trade := result.Trades[0]
		if trade.InstrumentID != market.InstrumentID("KRX:005930") {
			t.Errorf("expected trade instrument KRX:005930, got %s", trade.InstrumentID)
		}
		expectedQty := market.Quantity{Amount: market.Decimal{Value: "2"}}
		if trade.Quantity.Amount.Value != expectedQty.Amount.Value {
			t.Errorf("expected trade quantity %s, got %s", expectedQty.Amount.Value, trade.Quantity.Amount.Value)
		}
	}
}

// limitBuyStrategy returns a limit buy order on the first bar call.
type limitBuyStrategy struct {
	limitPrice market.Price
	callCount  int
}

func (s *limitBuyStrategy) ID() backtest.StrategyID {
	return "limit-buy-strategy"
}

func (s *limitBuyStrategy) Decide(input backtest.StrategyInput) ([]backtest.OrderIntent, error) {
	s.callCount++
	if s.callCount == 1 {
		return []backtest.OrderIntent{{
			InstrumentID: input.Bar.InstrumentID,
			Side:         backtest.OrderSideBuy,
			Quantity:     market.Quantity{Amount: market.Decimal{Value: "2"}},
			Type:         backtest.OrderTypeLimit,
			LimitPrice:   s.limitPrice,
		}}, nil
	}
	return nil, nil
}

// TestEngineQueuesOrdersByOrderInstrumentID proves that orders are enqueued by
// their own InstrumentID, not the bar's instrument.
//
// Fixture: A1 (May1, KRX:000660), A2 (May2, KRX:000660), B2 (May2, KRX:005930).
// No B1 bar exists, so a B order placed on A1 cannot fill until B2.
// Strategy: on A1 bar returns a B (KRX:005930) order; on all other bars returns nil.
//
// Correct keying (order.InstrumentID): B order sits in pendingOrders["KRX:005930"],
// fills on B2 at B2.Open=1100.
// Old buggy keying (bar.InstrumentID): B order sits in pendingOrders["KRX:000660"],
// fills on A2 at A2.Open=82000.
func TestEngineQueuesOrdersByOrderInstrumentID(t *testing.T) {
	barA1 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:000660"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "80000"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "80000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "79000"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "81000"}},
	}
	barA2 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:000660"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "82000"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "82000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "81000"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "83000"}},
	}
	// B2 is the only B bar; B1 is intentionally absent so the B order from A1 waits until B2.
	barB2 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1100"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1100"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1090"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1110"}},
	}

	// Sorted order: A1 (May1, 000660), A2 (May2, 000660), B2 (May2, 005930)
	crossInstStrat := &crossInstrumentStrategy{}
	store := newInMemoryResultStore()
	engine := NewEngine(&mockBarSource{bars: []market.Bar{barA1, barA2, barB2}}, &mockStrategyPort{strategy: crossInstStrat}, store)

	run := backtest.Run{
		ID: "run-cross-instrument",
		Spec: backtest.RunSpec{
			StrategyID: "cross-instrument-strategy",
			Market:     market.MarketKR,
			Timeframe:  market.TimeframeDaily,
			From:       time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
			To:         time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		},
	}

	if err := engine.Execute(context.Background(), run); err != nil {
		t.Fatalf("Engine execution failed: %v", err)
	}

	result, err := store.GetResult(context.Background(), run.ID)
	if err != nil {
		t.Fatalf("failed to get result: %v", err)
	}

	// B order from A1 must fill on B2 at B2.Open=1100, not on A2 at A2.Open=82000.
	// No A trade should exist.
	if len(result.Trades) != 1 {
		t.Fatalf("expected 1 trade, got %d", len(result.Trades))
	}
	trade := result.Trades[0]
	if trade.InstrumentID != market.InstrumentID("KRX:005930") {
		t.Errorf("expected trade instrument KRX:005930, got %s", trade.InstrumentID)
	}
	if trade.Price.Amount.Value != "1100" {
		t.Errorf("expected fill price B2.Open=1100, got %s (82000 means order was keyed by bar instrument)", trade.Price.Amount.Value)
	}
}

// crossInstrumentStrategy returns a KRX:005930 (B) order when processing the
// KRX:000660 (A) bar on its first call, and nil for all subsequent calls.
// This simulates a strategy that places an order for a different instrument than
// the bar being evaluated.
type crossInstrumentStrategy struct {
	decideCalls []backtest.StrategyInput
}

func (s *crossInstrumentStrategy) ID() backtest.StrategyID {
	return "cross-instrument"
}

func (s *crossInstrumentStrategy) Decide(input backtest.StrategyInput) ([]backtest.OrderIntent, error) {
	s.decideCalls = append(s.decideCalls, input)
	if len(s.decideCalls) == 1 {
		return []backtest.OrderIntent{{
			InstrumentID: market.InstrumentID("KRX:005930"),
			Side:         backtest.OrderSideBuy,
			Quantity:     market.Quantity{Amount: market.Decimal{Value: "1"}},
		}}, nil
	}
	return nil, nil
}

// TestEngineDoesNotFillPendingOrderWithoutNextBar proves that if the strategy
// places an order on the last bar in the series it is discarded, and verifies
// via the result store instead of strategy-local state.
func TestEngineDoesNotFillPendingOrderWithoutNextBar(t *testing.T) {
	bar1 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1000"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "990"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1010"}},
	}
	bar2 := market.Bar{
		InstrumentID: market.InstrumentID("KRX:005930"),
		Timeframe:    market.TimeframeDaily,
		Timestamp:    time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		Open:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1100"}},
		Close:        market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1100"}},
		Low:          market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1090"}},
		High:         market.Price{Currency: market.CurrencyKRW, Amount: market.Decimal{Value: "1110"}},
	}

	lastBarBuyStrategy := &lastBarBuyStrategy{}
	store := newInMemoryResultStore()
	barSource := &mockBarSource{bars: []market.Bar{bar1, bar2}}
	engine := NewEngine(barSource, &mockStrategyPort{strategy: lastBarBuyStrategy}, store)

	run := backtest.Run{
		ID: "run-last-bar",
		Spec: backtest.RunSpec{
			StrategyID: "last-bar-strategy",
			Market:     market.MarketKR,
			Timeframe:  market.TimeframeDaily,
			From:       time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC),
			To:         time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC),
		},
	}

	if err := engine.Execute(context.Background(), run); err != nil {
		t.Fatalf("Engine execution failed: %v", err)
	}

	result, err := store.GetResult(context.Background(), run.ID)
	if err != nil {
		t.Fatalf("failed to get result: %v", err)
	}

	// There should be no trades because the buy was placed on the last bar
	// and no next bar existed to execute it.
	if len(result.Trades) != 0 {
		t.Errorf("expected 0 trades (order discarded), got %d", len(result.Trades))
	}

	// No positions should be open
	if len(result.Positions) != 0 {
		t.Errorf("expected 0 positions, got %d", len(result.Positions))
	}

	// Ending equity should equal starting cash (10000000 KRW) since no trades occurred
	if result.EndingEquity.Amount.Value != startingCashKRW {
		t.Errorf("expected ending equity %s (starting cash), got %s", startingCashKRW, result.EndingEquity.Amount.Value)
	}
}

// lastBarBuyStrategy buys only on the last bar (day == 2).
type lastBarBuyStrategy struct {
	callCount int
}

func (s *lastBarBuyStrategy) ID() backtest.StrategyID {
	return "last-bar-strategy"
}

func (s *lastBarBuyStrategy) Decide(input backtest.StrategyInput) ([]backtest.OrderIntent, error) {
	s.callCount++
	if input.Bar.Timestamp.Day() != 2 {
		return nil, nil
	}
	return []backtest.OrderIntent{{
		InstrumentID: input.Bar.InstrumentID,
		Side:         backtest.OrderSideBuy,
		Quantity:     market.Quantity{Amount: market.Decimal{Value: "2"}},
	}}, nil
}

// NOTE: startingCashKRW constant for test assertions
const startingCashKRW = "10000000"