package table_test

import (
	"bytes"
	"strings"
	"testing"
	"time"

	"github.com/nmoniz/any2anexoj/internal"
<<<<<<<< HEAD:cmd/any2anexoj-cli/pretty_printer_test.go
========
	"github.com/nmoniz/any2anexoj/internal/writing"
	"github.com/nmoniz/any2anexoj/internal/writing/table"
	"github.com/shopspring/decimal"
)

func TestPrinter_Render(t *testing.T) {
	// Create test data
	aw := internal.NewAggregatorWriter()
	ctx := t.Context()

	// Add some sample report items
	err := aw.Write(ctx, internal.ReportItem{
		Symbol:        "AAPL",
		Nature:        internal.NatureG01,
		BrokerCountry: 826, // United Kingdom
		AssetCountry:  840, // United States
		BuyValue:      decimal.NewFromFloat(100.50),
		BuyTimestamp:  time.Date(2023, 1, 15, 0, 0, 0, 0, time.UTC),
		SellValue:     decimal.NewFromFloat(150.75),
		SellTimestamp: time.Date(2023, 6, 20, 0, 0, 0, 0, time.UTC),
		Fees:          decimal.NewFromFloat(2.50),
		Taxes:         decimal.NewFromFloat(5.00),
	})
	if err != nil {
		t.Fatalf("failed to write first report item: %v", err)
	}

	err = aw.Write(ctx, internal.ReportItem{
		Symbol:        "GOOGL",
		Nature:        internal.NatureG20,
		BrokerCountry: 826, // United Kingdom
		AssetCountry:  840, // United States
		BuyValue:      decimal.NewFromFloat(200.00),
		BuyTimestamp:  time.Date(2023, 3, 10, 0, 0, 0, 0, time.UTC),
		SellValue:     decimal.NewFromFloat(225.50),
		SellTimestamp: time.Date(2023, 9, 5, 0, 0, 0, 0, time.UTC),
		Fees:          decimal.NewFromFloat(3.00),
		Taxes:         decimal.NewFromFloat(7.50),
	})
	if err != nil {
		t.Fatalf("failed to write second report item: %v", err)
	}

	// Create English localizer
<<<<<<<< HEAD:cmd/any2anexoj-cli/pretty_printer_test.go
	localizer, err := NewLocalizer("en")
========
	localizer, err := writing.NewLocalizer("en")
>>>>>>>> 6ba3d78 (writers in writing package):internal/writing/pretty/printer_test.go
	if err != nil {
		t.Fatalf("failed to create localizer: %v", err)
	}

	// Create writing printer with buffer
	var buf bytes.Buffer
	pp := table.NewPrinter(&buf, localizer)

	// Render the table
	pp.Render(aw)

	// Get the output
	got := buf.String()

	// Expected output
	want := `┌───┬────────────────────────────┬───────────────────────────────────┬───────────────────────────────────┬──────────────────────────────────────────────────────────┐
│   │                            │            REALIZATION            │            ACQUISITION            │                                                          │
│   │ SOURCE COUNTRY      │ CODE │ YEAR │ MONTH │ DAY │        VALUE │ YEAR │ MONTH │ DAY │        VALUE │ EXPENSES AND CH │ TAX PAID ABROAD │ COUNTER COUNTRY      │
│   │                     │      │      │       │     │              │      │       │     │              │           ARGES │                 │                      │
├───┼─────────────────────┼──────┼──────┼───────┼─────┼──────────────┼──────┼───────┼─────┼──────────────┼─────────────────┼─────────────────┼──────────────────────┤
│ 1 │ 840 - United States │ G01  │ 2023 │ 6     │ 20  │     150.75 € │ 2023 │ 1     │ 15  │     100.50 € │          2.50 € │          5.00 € │ 826 - United Kingdom │
│ 2 │ 840 - United States │ G20  │ 2023 │ 9     │ 5   │     225.50 € │ 2023 │ 3     │ 10  │     200.00 € │          3.00 € │          7.50 € │ 826 - United Kingdom │
├───┼─────────────────────┴──────┴──────┴───────┴─────┼──────────────┼──────┴───────┴─────┼──────────────┼─────────────────┼─────────────────┼──────────────────────┤
│   │                                             SUM │     376.25 € │                    │     300.50 € │          5.50 € │         12.50 € │                      │
└───┴─────────────────────────────────────────────────┴──────────────┴────────────────────┴──────────────┴─────────────────┴─────────────────┴──────────────────────┘
`

	// Compare output
	if got != want {
		t.Errorf("Printer.Render() output doesn't match expected.\n\nGot:\n%s\n\nWant:\n%s", got, want)
	}
}

func TestRenderHTML(t *testing.T) {
	// Create test data
	aw := internal.NewAggregatorWriter()
	ctx := t.Context()

	err := aw.Write(ctx, internal.ReportItem{
		Symbol:        "AAPL",
		Nature:        internal.NatureG01,
		BrokerCountry: 826, // United Kingdom
		AssetCountry:  840, // United States
		BuyValue:      decimal.NewFromFloat(100.50),
		BuyTimestamp:  time.Date(2023, 1, 15, 0, 0, 0, 0, time.UTC),
		SellValue:     decimal.NewFromFloat(150.75),
		SellTimestamp: time.Date(2023, 6, 20, 0, 0, 0, 0, time.UTC),
		Fees:          decimal.NewFromFloat(2.50),
		Taxes:         decimal.NewFromFloat(5.00),
	})
	if err != nil {
		t.Fatalf("failed to write report item: %v", err)
	}

	// Create Portuguese localizer so the header text is in pt
	localizer, err := writing.NewLocalizer("pt")
	if err != nil {
		t.Fatalf("failed to create localizer: %v", err)
	}

	// Output buffer used only to satisfy the constructor contract; RenderHTML
	// must not write to it.
	var buf bytes.Buffer
	pp := table.NewPrinter(&buf, localizer)

	html := pp.RenderHTML(aw)

	// RenderHTML must not side-write to pp.output.
	if buf.Len() != 0 {
		t.Errorf("RenderHTML should not write to pp.output, but got %d bytes: %q", buf.Len(), buf.String())
	}

	// Structural assertions.
	wantSubstrings := []string{
		`<table class="table table-striped table-hover table-bordered">`,
		`</table>`,
		`<thead>`,
		`</thead>`,
		`<tbody>`,
		`</tbody>`,
		`<tfoot>`,
		`</tfoot>`,
		"Realização",
		"Aquisição",
		"Soma",
	}
	for _, s := range wantSubstrings {
		if !strings.Contains(html, s) {
			t.Errorf("RenderHTML output missing expected substring %q\nGot:\n%s", s, html)
		}
	}

	// Calling RenderHTML twice on the same instance must not duplicate rows.
	html2 := pp.RenderHTML(aw)
	if strings.Count(html2, "<tr") != strings.Count(html, "<tr") {
		t.Errorf("expected second RenderHTML call to produce the same number of rows as the first\nFirst (%d <tr>):\n%s\nSecond (%d <tr>):\n%s",
			strings.Count(html, "<tr"), html,
			strings.Count(html2, "<tr"), html2)
	}
}