package internal_test

import (
	"context"
	"fmt"
	"io"
	"reflect"
	"testing"
	"time"

	"github.com/biter777/countries"
	"github.com/nmoniz/any2anexoj/internal"
	"github.com/nmoniz/any2anexoj/internal/mocks"
	"github.com/shopspring/decimal"
	"go.uber.org/mock/gomock"
)

func TestBuildReport(t *testing.T) {
	now := time.Now()
	ctrl := gomock.NewController(t)

	reader := mocks.NewMockRecordReader(ctrl)
	records := []internal.Record{
		mockRecord(ctrl, 20.0, 10.0, internal.KindBuy, now),
		mockRecord(ctrl, 25.0, 10.0, internal.KindSell, now.Add(1)),
	}
	reader.EXPECT().ReadRecord(gomock.Any()).DoAndReturn(func(ctx context.Context) (internal.Record, error) {
		if len(records) > 0 {
			r := records[0]
			records = records[1:]
			return r, nil
		} else {
			return nil, io.EOF
		}
	}).Times(3)

	writer := mocks.NewMockReportWriter(ctrl)
	writer.EXPECT().Write(gomock.Any(), eqReportItem(internal.ReportItem{
		BuyValue:      decimal.NewFromFloat(200.0),
		BuyTimestamp:  now,
		SellValue:     decimal.NewFromFloat(250.0),
		SellTimestamp: now.Add(1),
		Fees:          decimal.Decimal{},
		Taxes:         decimal.Decimal{},
	})).Times(1)

	gotErr := internal.BuildReport(t.Context(), reader, writer)
	if gotErr != nil {
		t.Fatalf("got unexpected err: %v", gotErr)
	}
}

func mockRecord(ctrl *gomock.Controller, price, quantity float64, kind internal.Kind, ts time.Time) *mocks.MockRecord {
	rec := mocks.NewMockRecord(ctrl)
	rec.EXPECT().Symbol().Return("TEST").AnyTimes()
	rec.EXPECT().BrokerCountry().Return(int64(countries.PT)).AnyTimes()
	rec.EXPECT().AssetCountry().Return(int64(countries.USA)).AnyTimes()
	rec.EXPECT().Price().Return(decimal.NewFromFloat(price)).AnyTimes()
	rec.EXPECT().Quantity().Return(decimal.NewFromFloat(quantity)).AnyTimes()
	rec.EXPECT().Kind().Return(kind).AnyTimes()
	rec.EXPECT().Timestamp().Return(ts).AnyTimes()
	rec.EXPECT().Fees().Return(decimal.Decimal{}).AnyTimes()
	rec.EXPECT().Taxes().Return(decimal.Decimal{}).AnyTimes()
	rec.EXPECT().Nature().Return(internal.NatureG01).AnyTimes()
	return rec
}

func eqReportItem(ri internal.ReportItem) ReportItemMatcher {
	return ReportItemMatcher{
		ReportItem: ri,
	}
}

type ReportItemMatcher struct {
	internal.ReportItem
}

// Matches implements gomock.Matcher.
func (m ReportItemMatcher) Matches(x any) bool {
	if x == nil {
		return false
	}

	switch other := x.(type) {
	case internal.ReportItem:
		return m.BuyValue.Equal(other.BuyValue) &&
			m.BuyTimestamp.Equal(other.BuyTimestamp) &&
			m.SellValue.Equal(other.SellValue) &&
			m.SellTimestamp.Equal(other.SellTimestamp) &&
			m.Fees.Equal(other.Fees) &&
			m.Taxes.Equal(other.Taxes)
	default:
		return false
	}
}

func (m ReportItemMatcher) String() string {
	return fmt.Sprintf("is equivalent to %v", m.ReportItem)
}

var _ gomock.Matcher = (*ReportItemMatcher)(nil)

// recordingStore is a test fake for internal.Store that records how many
// times Load/Save were invoked and captures the maps it handed back so a
// test can verify BuildReport wires the store correctly.
type recordingStore struct {
	loadCalls int
	saveCalls int
	loaded    map[string]*internal.FillerQueue
	saved     map[string]*internal.FillerQueue
}

func (s *recordingStore) Load(_ context.Context) (map[string]*internal.FillerQueue, error) {
	s.loadCalls++
	if s.loaded == nil {
		s.loaded = map[string]*internal.FillerQueue{}
	}
	return s.loaded, nil
}

func (s *recordingStore) Save(_ context.Context, queues map[string]*internal.FillerQueue) error {
	s.saveCalls++
	s.saved = queues
	return nil
}

func TestBuildReport_WithStore(t *testing.T) {
	now := time.Now()
	ctrl := gomock.NewController(t)

	reader := mocks.NewMockRecordReader(ctrl)
	records := []internal.Record{
		mockRecord(ctrl, 20.0, 10.0, internal.KindBuy, now),
	}
	reader.EXPECT().ReadRecord(gomock.Any()).DoAndReturn(func(ctx context.Context) (internal.Record, error) {
		if len(records) > 0 {
			r := records[0]
			records = records[1:]
			return r, nil
		}
		return nil, io.EOF
	}).Times(2)

	// No sells, so the writer must not be called.
	writer := mocks.NewMockReportWriter(ctrl)

	store := &recordingStore{}

	gotErr := internal.BuildReport(t.Context(), reader, writer, internal.WithStore(store))
	if gotErr != nil {
		t.Fatalf("got unexpected err: %v", gotErr)
	}

	if store.loadCalls != 1 {
		t.Errorf("Load calls: want 1 but got %d", store.loadCalls)
	}
	if store.saveCalls != 1 {
		t.Errorf("Save calls: want 1 but got %d", store.saveCalls)
	}

	// Load must run before any records are read, so it has already been
	// invoked by the time Save is observed.
	if store.loadCalls < store.saveCalls {
		t.Errorf("Load (%d) should be called at least as many times as Save (%d)", store.loadCalls, store.saveCalls)
	}

	if store.loaded == nil {
		t.Fatalf("Load was not called or returned a nil map")
	}
	if store.saved == nil {
		t.Fatalf("Save was not called or received a nil map")
	}

	// The map handed to Save must be the same map returned by Load so
	// that buy-queue mutations done while processing flow into Save.
	if reflect.ValueOf(store.loaded).Pointer() != reflect.ValueOf(store.saved).Pointer() {
		t.Errorf("map passed to Save is not the same map returned by Load")
	}

	// Sanity: the buy record above should have populated an entry for the
	// "TEST" symbol in the shared map.
	if _, ok := store.saved["TEST"]; !ok {
		t.Errorf("want saved map to contain symbol %q but it was missing", "TEST")
	}
}