Implement HTML writer (#33)

Reviewed-on: #33
Co-authored-by: Natercio Moniz <[email protected]>

internal/writing/csv/writer.go

@@ -0,0 +1,59 @@
+// Package csv renders an internal.AggregatorWriter as the CSV schema
+// expected by Modelo 3 do Anexo J.
+package csv
+
+import (
+	"encoding/csv"
+	"fmt"
+	"io"
+
+	"github.com/nmoniz/any2anexoj/internal"
+)
+
+type Writer struct {
+	w *csv.Writer
+}
+
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{w: csv.NewWriter(w)}
+}
+
+func (cw *Writer) Render(aw *internal.AggregatorWriter) error {
+	err := cw.w.Write([]string{
+		"source_country", "code",
+		"realization_year", "realization_month", "realization_day", "realization_value",
+		"acquisition_year", "acquisition_month", "acquisition_day", "acquisition_value",
+		"expenses", "foreign_tax_paid", "counter_country",
+	})
+	if err != nil {
+		return fmt.Errorf("write csv header: %w", err)
+	}
+
+	for ri := range aw.Iter() {
+		err := cw.w.Write(reportItemToRow(ri))
+		if err != nil {
+			return fmt.Errorf("write csv row: %w", err)
+		}
+	}
+
+	cw.w.Flush()
+	return cw.w.Error()
+}
+
+func reportItemToRow(ri internal.ReportItem) []string {
+	return []string{
+		fmt.Sprintf("%d", ri.AssetCountry),
+		string(ri.Nature),
+		fmt.Sprintf("%d", ri.SellTimestamp.Year()),
+		fmt.Sprintf("%d", int(ri.SellTimestamp.Month())),
+		fmt.Sprintf("%d", ri.SellTimestamp.Day()),
+		ri.SellValue.StringFixed(2),
+		fmt.Sprintf("%d", ri.BuyTimestamp.Year()),
+		fmt.Sprintf("%d", int(ri.BuyTimestamp.Month())),
+		fmt.Sprintf("%d", ri.BuyTimestamp.Day()),
+		ri.BuyValue.StringFixed(2),
+		ri.Fees.StringFixed(2),
+		ri.Taxes.StringFixed(2),
+		fmt.Sprintf("%d", ri.BrokerCountry),
+	}
+}

internal/writing/csv/writer_test.go

@@ -0,0 +1,78 @@
+package csv_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing/csv"
+	"github.com/shopspring/decimal"
+)
+
+func TestWriter_Render(t *testing.T) {
+	aw := internal.NewAggregatorWriter()
+	ctx := t.Context()
+
+	items := []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),
+		},
+		{
+			Symbol:        "VWRL",
+			Nature:        internal.NatureG20,
+			BrokerCountry: 196, // Portugal equivalent demo
+			AssetCountry:  372, // Ireland
+			BuyValue:      decimal.NewFromFloat(200.00),
+			BuyTimestamp:  time.Date(2024, 2, 1, 0, 0, 0, 0, time.UTC),
+			SellValue:     decimal.NewFromFloat(250.25),
+			SellTimestamp: time.Date(2024, 7, 10, 0, 0, 0, 0, time.UTC),
+			Fees:          decimal.NewFromFloat(1.00),
+			Taxes:         decimal.NewFromFloat(0.00),
+		},
+	}
+
+	for _, ri := range items {
+		if err := aw.Write(ctx, ri); err != nil {
+			t.Fatalf("write report item: %v", err)
+		}
+	}
+
+	var buf bytes.Buffer
+	if err := csv.NewWriter(&buf).Render(aw); err != nil {
+		t.Fatalf("render: %v", err)
+	}
+
+	out := buf.String()
+
+	wantHeader := "source_country,code,realization_year,realization_month,realization_day,realization_value,acquisition_year,acquisition_month,acquisition_day,acquisition_value,expenses,foreign_tax_paid,counter_country"
+	if !strings.HasPrefix(out, wantHeader+"\n") {
+		t.Errorf("expected header row %q, got output:\n%s", wantHeader, out)
+	}
+
+	wantRow1 := "840,G01,2023,6,20,150.75,2023,1,15,100.50,2.50,5.00,826"
+	if !strings.Contains(out, wantRow1+"\n") {
+		t.Errorf("expected row 1 %q in output:\n%s", wantRow1, out)
+	}
+
+	wantRow2 := "372,G20,2024,7,10,250.25,2024,2,1,200.00,1.00,0.00,196"
+	if !strings.Contains(out, wantRow2+"\n") {
+		t.Errorf("expected row 2 %q in output:\n%s", wantRow2, out)
+	}
+
+	// Make sure the header only appears once and we have exactly 1 header + 2 data rows.
+	lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
+	if got, want := len(lines), 3; got != want {
+		t.Errorf("expected %d lines (1 header + 2 rows), got %d:\n%s", want, got, out)
+	}
+}

internal/writing/html/bootstrap.min.css

@@ -0,0 +1,6 @@
+@charset "UTF-8";/*!
+ * Bootstrap  v5.3.3 (https://getbootstrap.com/)
+ * Copyright 2011-2024 The Bootstrap Authors
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ */:root,[data-bs-theme=light]{--bs-blue:#0d6efd;--bs-indigo:#6610f2;--bs-purple:#6f42c1;--bs-pink:#d63384;--bs-red:#dc3545;--bs-orange:#fd7e14;--bs-yellow:#ffc107;--bs-green:#198754;--bs-teal:#20c997;--bs-cyan:#0dcaf0;--bs-black:#000;--bs-white:#fff;--bs-gray:#6c757d;--bs-gray-dark:#343a40;--bs-gray-100:#f8f9fa;--bs-gray-200:#e9ecef;--bs-gray-300:#dee2e6;--bs-gray-400:#ced4da;--bs-gray-500:#adb5bd;--bs-gray-600:#6c757d;--bs-gray-700:#495057;--bs-gray-800:#343a40;--bs-gray-900:#212529;--bs-primary:#0d6efd;--bs-secondary:#6c757d;--bs-success:#198754;--bs-info:#0dcaf0;--bs-warning:#ffc107;--bs-danger:#dc3545;--bs-light:#f8f9fa;--bs-dark:#212529;--bs-primary-rgb:13,110,253;--bs-secondary-rgb:108,117,125;--bs-success-rgb:25,135,84;--bs-info-rgb:13,202,240;--bs-warning-rgb:255,193,7;--bs-danger-rgb:220,53,69;--bs-light-rgb:248,249,250;--bs-dark-rgb:33,37,41;--bs-primary-text-emphasis:#052c65;--bs-secondary-text-emphasis:#2b2f32;--bs-success-text-emphasis:#0a3622;--bs-info-text-emphasis:#055160;--bs-warning-text-emphasis:#664d03;--bs-danger-text-emphasis:#58151c;--bs-light-text-emphasis:#495057;--bs-dark-text-emphasis:#495057;--bs-primary-bg-subtle:#cfe2ff;--bs-secondary-bg-subtle:#e2e3e5;--bs-success-bg-subtle:#d1e7dd;--bs-info-bg-subtle:#cff4fc;--bs-warning-bg-subtle:#fff3cd;--bs-danger-bg-subtle:#f8d7da;--bs-light-bg-subtle:#fcfcfd;--bs-dark-bg-subtle:#ced4da;--bs-primary-border-subtle:#9ec5fe;--bs-secondary-border-subtle:#c4c8cb;--bs-success-border-subtle:#a3cfbb;--bs-info-border-subtle:#9eeaf9;--bs-warning-border-subtle:#ffe69c;--bs-danger-border-subtle:#f1aeb5;--bs-light-border-subtle:#e9ecef;--bs-dark-border-subtle:#adb5bd;--bs-white-rgb:255,255,255;--bs-black-rgb:0,0,0;--bs-font-sans-serif:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue","Noto Sans","Liberation Sans",Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--bs-font-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--bs-gradient:linear-gradient(180deg, rgba(255, 255, 255, 0.15), rgba(255, 255, 255, 0));--bs-body-font-family:var(--bs-font-sans-serif);--bs-body-font-size:1rem;--bs-body-font-weight:400;--bs-body-line-height:1.5;--bs-body-color:#212529;--bs-body-color-rgb:33,37,41;--bs-body-bg:#fff;--bs-body-bg-rgb:255,255,255;--bs-emphasis-color:#000;--bs-emphasis-color-rgb:0,0,0;--bs-secondary-color:rgba(33, 37, 41, 0.75);--bs-secondary-color-rgb:33,37,41;--bs-secondary-bg:#e9ecef;--bs-secondary-bg-rgb:233,236,239;--bs-tertiary-color:rgba(33, 37, 41, 0.5);--bs-tertiary-color-rgb:33,37,41;--bs-tertiary-bg:#f8f9fa;--bs-tertiary-bg-rgb:248,249,250;--bs-heading-color:inherit;--bs-link-color:#0d6efd;--bs-link-color-rgb:13,110,253;--bs-link-decoration:underline;--bs-link-hover-color:#0a58ca;--bs-link-hover-color-rgb:10,88,202;--bs-code-color:#d63384;--bs-highlight-color:#212529;--bs-highlight-bg:#fff3cd;--bs-border-width:1px;--bs-border-style:solid;--bs-border-color:#dee2e6;--bs-border-color-translucent:rgba(0, 0, 0, 0.175);--bs-border-radius:0.375rem;--bs-border-radius-sm:0.25rem;--bs-border-radius-lg:0.5rem;--bs-border-radius-xl:1rem;--bs-border-radius-xxl:2rem;--bs-border-radius-2xl:var(--bs-border-radius-xxl);--bs-border-radius-pill:50rem;--bs-box-shadow:0 0.5rem 1rem rgba(0, 0, 0, 0.15);--bs-box-shadow-sm:0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);--bs-box-shadow-lg:0 1rem 3rem rgba(0, 0, 0, 0.175);--bs-box-shadow-inset:inset 0 1px 2px rgba(0, 0, 0, 0.075);--bs-focus-ring-width:0.25rem;--bs-focus-ring-opacity:0.25;--bs-focus-ring-color:rgba(13, 110, 253, 0.25);--bs-form-valid-color:#198754;--bs-form-valid-border-color:#198754;--bs-form-invalid-color:#dc3545;--bs-form-invalid-border-color:#dc3545}[data-bs-theme=dark]{color-scheme:dark;--bs-body-color:#dee2e6;--bs-body-color-rgb:222,226,230;--bs-body-bg:#212529;--bs-body-bg-rgb:33,37,41;--bs-emphasis-color:#fff;--bs-emphasis-color-rgb:255,255,255;--bs-secondary-color:rgba(222, 226, 230, 0.75);--bs-secondary-color-rgb:222,226,230;--bs-secondary-bg:#343a40;--bs-secondary-bg-rgb:52,58,64;--bs-tertiary-color:rgba(222, 226, 230, 0.5);--bs-tertiary-color-rgb:222,226,230;--bs-tertiary-bg:#2b3035;--bs-tertiary-bg-rgb:43,48,53;--bs-primary-text-emphasis:#6ea8fe;--bs-secondary-text-emphasis:#a7acb1;--bs-success-text-emphasis:#75b798;--bs-info-text-emphasis:#6edff6;--bs-warning-text-emphasis:#ffda6a;--bs-danger-text-emphasis:#ea868f;--bs-light-text-emphasis:#f8f9fa;--bs-dark-text-emphasis:#dee2e6;--bs-primary-bg-subtle:#031633;--bs-secondary-bg-subtle:#161719;--bs-success-bg-subtle:#051b11;--bs-info-bg-subtle:#032830;--bs-warning-bg-subtle:#332701;--bs-danger-bg-subtle:#2c0b0e;--bs-light-bg-subtle:#343a40;--bs-dark-bg-subtle:#1a1d20;--bs-primary-border-subtle:#084298;--bs-secondary-border-subtle:#41464b;--bs-success-border-subtle:#0f5132;--bs-info-border-subtle:#087990;--bs-warning-border-subtle:#997404;--bs-danger-border-subtle:#842029;--bs-light-border-subtle:#495057;--bs-dark-border-subtle:#343a40;--bs-heading-color:inherLine truncated
+/*# sourceMappingURL=bootstrap.min.css.map */

internal/writing/html/document.tmpl

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="{{.Lang}}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>{{.Title}}</title>
+<style>{{.CSS}}</style>
+</head>
+<body>
+<main class="container-fluid py-4">
+<h1>{{.Title}}</h1>
+<div class="table-responsive">
+{{.TableFragment}}
+</div>
+<p class="text-muted small">Generated at {{.GeneratedAt}}</p>
+</main>
+</body>
+</html>

internal/writing/html/fragment.go

@@ -0,0 +1,69 @@
+package html
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing/internal/tabledef"
+)
+
+// htmlCSSClass is the CSS class list put on the rendered report table.
+const htmlCSSClass = "table table-striped table-hover table-bordered"
+
+// widthIndex is the weight of the auto-index (row number) column; the other
+// column weights come from tabledef's width budgets.
+const widthIndex = 6
+
+// htmlColumnWeights lists one weight per rendered column, starting with the
+// auto-index column, mirroring the column order of tabledef.Build so the
+// HTML table keeps columns in the same strict proportion to each other as
+// the terminal layout.
+var htmlColumnWeights = []int{
+	widthIndex,
+	tabledef.WidthCountry, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthEuros,
+	tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthOther, tabledef.WidthEuros,
+	tabledef.WidthEuros, tabledef.WidthEuros, tabledef.WidthCountry,
+}
+
+// renderTableFragment renders aw as the Bootstrap-styled HTML <table>
+// fragment embedded in the document. The table gets a fixed layout with
+// strictly proportional column widths, so the browser — not this package —
+// decides when a header or cell wraps: on wide screens everything fits on
+// one line, on narrow ones it wraps automatically.
+func (hw *Writer) renderTableFragment(aw *internal.AggregatorWriter) string {
+	t := tabledef.Build(hw.translator, aw)
+	t.Style().HTML = table.HTMLOptions{
+		CSSClass:    htmlCSSClass,
+		EscapeText:  true,
+		Newline:     "<br/>",
+		EmptyColumn: "&nbsp;",
+	}
+	html := t.RenderHTML()
+
+	// go-pretty cannot emit table-level attributes or a <colgroup>, so splice
+	// them into its output: the fixed layout makes the colgroup's relative
+	// widths authoritative instead of content-driven column sizing.
+	openTag := `<table class="` + htmlCSSClass + `">`
+	fixedTag := `<table class="` + htmlCSSClass + `" style="table-layout: fixed">` + "\n" + colgroupHTML()
+	return strings.Replace(html, openTag, fixedTag, 1)
+}
+
+// colgroupHTML returns a <colgroup> with one <col> per rendered column, each
+// sized strictly in proportion to its weight. With the fixed table layout
+// applied in renderTableFragment these widths are authoritative: wide
+// viewports fit headers on a single line, narrow ones wrap automatically.
+func colgroupHTML() string {
+	var total int
+	for _, w := range htmlColumnWeights {
+		total += w
+	}
+	var sb strings.Builder
+	sb.WriteString("<colgroup>")
+	for _, w := range htmlColumnWeights {
+		fmt.Fprintf(&sb, `<col style="width: %.2f%%">`, float64(w)/float64(total)*100)
+	}
+	sb.WriteString("</colgroup>")
+	return sb.String()
+}

internal/writing/html/fragment_test.go

@@ -0,0 +1,60 @@
+package html_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/nmoniz/any2anexoj/internal/writing"
+	htmlwriter "github.com/nmoniz/any2anexoj/internal/writing/html"
+)
+
+// TestWriter_RenderTableFragment renders a Portuguese document and asserts
+// the embedded report table fragment carries the shared structure: the
+// translated headers, the totals footer, and the strictly proportional
+// colgroup that keeps HTML columns in the same relation to each other as
+// the terminal layout.
+func TestWriter_RenderTableFragment(t *testing.T) {
+	aw := buildTestAggregator(t)
+
+	localizer, err := writing.NewLocalizer("pt")
+	if err != nil {
+		t.Fatalf("failed to create localizer: %v", err)
+	}
+
+	var buf bytes.Buffer
+	hw := htmlwriter.NewWriter(&buf, localizer, "pt")
+
+	if err := hw.Render(aw); err != nil {
+		t.Fatalf("Render returned an error: %v", err)
+	}
+	got := buf.String()
+
+	wantSubstrings := []string{
+		`<table class="table table-striped table-hover table-bordered" style="table-layout: fixed">`,
+		`<colgroup>`,
+		`</colgroup>`,
+		`<col style="width: 3.03%">`,
+		`<col style="width: 12.12%">`,
+		`</table>`,
+		`<thead>`,
+		`</thead>`,
+		`<tbody>`,
+		`</tbody>`,
+		`<tfoot>`,
+		`</tfoot>`,
+		"Realização",
+		"Aquisição",
+		"Soma",
+	}
+	for _, s := range wantSubstrings {
+		if !strings.Contains(got, s) {
+			t.Errorf("rendered document missing expected substring %q\nGot:\n%s", s, got)
+		}
+	}
+
+	// The fragment must be embedded raw, not HTML-escaped.
+	if strings.Contains(got, "&lt;table") {
+		t.Errorf("table fragment appears to be HTML-escaped; expected raw <table> markup\nGot:\n%s", got)
+	}
+}

internal/writing/html/writer.go

@@ -0,0 +1,85 @@
+// Package html renders an internal.AggregatorWriter as a complete,
+// standalone HTML document: the report table fragment (built from the
+// shared table definition in internal/writing/internal/tabledef, so it can
+// never drift from the terminal layout) embedded in a Bootstrap-styled page
+// with a translated title and generation timestamp. The official Bootstrap
+// 5.3.3 stylesheet is inlined via go:embed, so the document renders fully
+// offline.
+package html
+
+import (
+	_ "embed"
+	"fmt"
+	"html/template"
+	"io"
+	"time"
+
+	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing/internal/tabledef"
+)
+
+// bootstrapMinCSS is the official Bootstrap 5.3.3 minified CSS distribution
+// file, embedded so every rendered document renders fully offline. After any
+// version bump, re-verify provenance with:
+//
+//	openssl dgst -sha384 -binary bootstrap.min.css | base64
+//
+// It must print the official SRI hash published at
+// https://getbootstrap.com/docs/5.3/getting-started/download/
+// (sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH).
+//
+//go:embed bootstrap.min.css
+var bootstrapMinCSS string
+
+// Writer writes a complete HTML document for an AggregatorWriter.
+type Writer struct {
+	output     io.Writer
+	translator tabledef.Translator
+	lang       string
+}
+
+// NewWriter builds a Writer that writes a complete HTML document to w. The
+// report table is rendered from the shared table definition via tr, and the
+// document title is looked up from the "report_title" translation via tr,
+// so callers never pass a pre-baked title.
+func NewWriter(w io.Writer, tr tabledef.Translator, lang string) *Writer {
+	return &Writer{
+		output:     w,
+		translator: tr,
+		lang:       lang,
+	}
+}
+
+//go:embed document.tmpl
+var documentTemplateBody string
+
+// documentTemplate renders the full HTML page from document.tmpl. The table
+// fragment is typed as template.HTML so the template engine emits it
+// verbatim without escaping the angle brackets in the <table> markup.
+var documentTemplate = template.Must(template.New("html").Parse(documentTemplateBody))
+
+// Render writes a complete standalone HTML document for aw to the configured
+// output. The same Writer may be reused; each call rebuilds the table
+// fragment from aw so the rendered <tr> count reflects aw's current items and
+// no rows are duplicated across invocations.
+func (hw *Writer) Render(aw *internal.AggregatorWriter) error {
+	fragment := hw.renderTableFragment(aw)
+	title := hw.translator.Translate("report_title", 1, nil)
+	data := struct {
+		Lang          string
+		Title         string
+		CSS           template.CSS
+		TableFragment template.HTML
+		GeneratedAt   string
+	}{
+		Lang:          hw.lang,
+		Title:         title,
+		CSS:           template.CSS(bootstrapMinCSS),
+		TableFragment: template.HTML(fragment),
+		GeneratedAt:   time.Now().UTC().Format(time.RFC3339),
+	}
+	if err := documentTemplate.Execute(hw.output, data); err != nil {
+		return fmt.Errorf("render html document: %w", err)
+	}
+	return nil
+}

internal/writing/html/writer_test.go

@@ -0,0 +1,188 @@
+package html_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing"
+	htmlwriter "github.com/nmoniz/any2anexoj/internal/writing/html"
+	"github.com/shopspring/decimal"
+)
+
+// buildTestAggregator returns an AggregatorWriter seeded with two
+// deterministic ReportItems so every test can assert on a stable document
+// shape. Mirrors the fixture pattern used in
+// internal/writing/table/printer_test.go.
+func buildTestAggregator(t *testing.T) *internal.AggregatorWriter {
+	t.Helper()
+	aw := internal.NewAggregatorWriter()
+	ctx := t.Context()
+
+	err := aw.Write(ctx, internal.ReportItem{
+		Symbol:        "AAPL",
+		Nature:        internal.NatureG01,
+		BrokerCountry: 826,
+		AssetCountry:  840,
+		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,
+		AssetCountry:  840,
+		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)
+	}
+
+	return aw
+}
+
+func TestWriter_Render(t *testing.T) {
+	loc, err := writing.NewLocalizer("en")
+	if err != nil {
+		t.Fatalf("create localizer: %v", err)
+	}
+
+	var buf bytes.Buffer
+	hw := htmlwriter.NewWriter(&buf, loc, "en")
+
+	if err := hw.Render(buildTestAggregator(t)); err != nil {
+		t.Fatalf("Render returned an error: %v", err)
+	}
+
+	got := buf.String()
+
+	wantSubstrings := []string{
+		"<!DOCTYPE html>",
+		`<html lang="en">`,
+		`<meta charset="utf-8">`,
+		`<meta name="viewport" content="width=device-width, initial-scale=1">`,
+		`<title>Tax report</title>`,
+		`<style>`,
+		`Bootstrap  v5.3.3`,
+		`<main class="container-fluid py-4">`,
+		`<h1>Tax report</h1>`,
+		`<div class="table-responsive">`,
+		`<table class="table table-striped table-hover table-bordered" style="table-layout: fixed">`,
+		`<colgroup>`,
+		`</table>`,
+		`<tfoot>`,
+		`</tfoot>`,
+		`</html>`,
+		`<p class="text-muted small">Generated at `,
+	}
+	for _, s := range wantSubstrings {
+		if !strings.Contains(got, s) {
+			t.Errorf("rendered HTML missing expected substring %q\nGot:\n%s", s, got)
+		}
+	}
+
+	// The table fragment must be embedded as raw HTML, not escaped.
+	if strings.Contains(got, "&lt;table") {
+		t.Errorf("table fragment appears to be HTML-escaped; expected raw <table> markup\nGot:\n%s", got)
+	}
+	if !strings.Contains(got, "<table") {
+		t.Errorf("expected raw <table> tag in output\nGot:\n%s", got)
+	}
+
+	// The document must be fully self-contained: no external stylesheet
+	// <link> and no CDN reference anywhere.
+	if strings.Contains(got, "<link") {
+		t.Errorf("expected no external stylesheet <link>; document must be self-contained\nGot:\n%s", got)
+	}
+	if strings.Contains(got, "cdn.jsdelivr.net") {
+		t.Errorf("expected no CDN references; document must be self-contained\nGot:\n%s", got)
+	}
+
+	// Generated timestamp must be valid RFC3339 UTC.
+	startIdx := strings.Index(got, "Generated at ")
+	if startIdx == -1 {
+		t.Fatalf("missing 'Generated at' prefix in output")
+	}
+	timestampLine := got[startIdx:]
+	endIdx := strings.Index(timestampLine, "</p>")
+	if endIdx == -1 {
+		t.Fatalf("missing </p> closing tag after 'Generated at' line")
+	}
+	timestampStr := strings.TrimPrefix(strings.SplitN(timestampLine, "</p>", 2)[0], "Generated at ")
+	if _, err := time.Parse(time.RFC3339, timestampStr); err != nil {
+		t.Errorf("generation timestamp is not valid RFC3339: %q (err: %v)", timestampStr, err)
+	}
+}
+
+// TestWriter_NoRowDuplication verifies that calling Render twice on the
+// same writer produces documents with the same number of <tr> rows, just
+// like table.Printer's no-duplication guarantee.
+func TestWriter_NoRowDuplication(t *testing.T) {
+	loc, err := writing.NewLocalizer("en")
+	if err != nil {
+		t.Fatalf("create localizer: %v", err)
+	}
+
+	var buf bytes.Buffer
+	hw := htmlwriter.NewWriter(&buf, loc, "en")
+
+	aw := buildTestAggregator(t)
+
+	if err := hw.Render(aw); err != nil {
+		t.Fatalf("first Render returned an error: %v", err)
+	}
+	first := buf.String()
+	buf.Reset()
+
+	if err := hw.Render(aw); err != nil {
+		t.Fatalf("second Render returned an error: %v", err)
+	}
+	second := buf.String()
+
+	firstRows := strings.Count(first, "<tr")
+	secondRows := strings.Count(second, "<tr")
+	if firstRows == 0 {
+		t.Fatalf("expected at least one <tr> row in the first render; got:\n%s", first)
+	}
+	if firstRows != secondRows {
+		t.Errorf("expected second Render to produce the same number of <tr> rows as the first (no duplication)\nfirst rows=%d, second rows=%d\nFirst:\n%s\nSecond:\n%s",
+			firstRows, secondRows, first, second)
+	}
+}
+
+func TestWriter_LangAttribute(t *testing.T) {
+	loc, err := writing.NewLocalizer("pt")
+	if err != nil {
+		t.Fatalf("create localizer: %v", err)
+	}
+
+	var buf bytes.Buffer
+	hw := htmlwriter.NewWriter(&buf, loc, "pt")
+
+	if err := hw.Render(buildTestAggregator(t)); err != nil {
+		t.Fatalf("Render returned an error: %v", err)
+	}
+
+	got := buf.String()
+	if !strings.Contains(got, `<html lang="pt">`) {
+		t.Errorf("expected <html lang=\"pt\"> attribute; got:\n%s", got)
+	}
+	if !strings.Contains(got, `<h1>Relatório fiscal</h1>`) {
+		t.Errorf("expected Portuguese title in <h1>; got:\n%s", got)
+	}
+}

internal/writing/internal/tabledef/table.go

@@ -0,0 +1,154 @@
+// Package tabledef holds the single definition of the Anexo J report table
+// — column configuration, translated headers, data rows and the totals
+// footer — shared by every renderer under internal/writing. Living in a
+// writing-internal package lets the table and html packages project the
+// same structure into their own formats without any of them exposing
+// go-pretty types in their public API.
+package tabledef
+
+import (
+	"fmt"
+
+	"github.com/biter777/countries"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/jedib0t/go-pretty/v6/text"
+	"github.com/nmoniz/any2anexoj/internal"
+)
+
+// Translator is the contract the report table renderers rely on for
+// human-readable column labels. *writing.Localizer satisfies it.
+type Translator interface {
+	Translate(key string, count int, values map[string]any) string
+}
+
+// Column width budgets enforced by the terminal renderer. The html package
+// derives its proportional column widths from the same values, keeping both
+// renderings in the same strict proportion to each other.
+const (
+	// WidthCountry is the width budget of a country column ("code - name").
+	WidthCountry = 24
+	// WidthOther is the width budget of a plain column (code, year, ...).
+	WidthOther = 12
+	// WidthEuros is the width budget of a money column ("123.45 €").
+	WidthEuros = 15
+)
+
+// Build constructs a fully configured go-pretty table.Writer from the items
+// in aw: one column per report field, translated headers, data rows and the
+// totals footer. Each call returns a fresh table so callers can render the
+// same data multiple times without duplicating rows, and the returned table
+// is not wired to any output.
+//
+// Change columns, headers or footers here so every renderer stays in sync.
+func Build(tr Translator, aw *internal.AggregatorWriter) table.Writer {
+	tw := table.NewWriter()
+	tw.SetAutoIndex(true)
+	tw.SetStyle(table.StyleLight)
+	tw.SetColumnConfigs([]table.ColumnConfig{
+		colCountry(1),
+		colOther(2),
+		colOther(3),
+		colOther(4),
+		colOther(5),
+		colEuros(6),
+		colOther(7),
+		colOther(8),
+		colOther(9),
+		colEuros(10),
+		colEuros(11),
+		colEuros(12),
+		colCountry(13),
+	})
+
+	realizationTxt := tr.Translate("realization", 1, nil)
+	acquisitionTxt := tr.Translate("acquisition", 1, nil)
+	yearTxt := tr.Translate("year", 1, nil)
+	monthTxt := tr.Translate("month", 1, nil)
+	dayTxt := tr.Translate("day", 1, nil)
+	valorTxt := tr.Translate("value", 1, nil)
+
+	tw.AppendHeader(table.Row{"", "", realizationTxt, realizationTxt, realizationTxt, realizationTxt, acquisitionTxt, acquisitionTxt, acquisitionTxt, acquisitionTxt, "", "", ""}, table.RowConfig{AutoMerge: true})
+	tw.AppendHeader(table.Row{
+		tr.Translate("source_country", 1, nil), tr.Translate("code", 1, nil),
+		yearTxt, monthTxt, dayTxt, valorTxt,
+		yearTxt, monthTxt, dayTxt, valorTxt,
+		tr.Translate("expenses", 2, nil), tr.Translate("foreign_tax_paid", 1, nil), tr.Translate("counter_country", 1, nil),
+	})
+
+	for ri := range aw.Iter() {
+		tw.AppendRow(table.Row{
+			ri.AssetCountry, ri.Nature,
+			ri.SellTimestamp.Year(), int(ri.SellTimestamp.Month()), ri.SellTimestamp.Day(), ri.SellValue.StringFixed(2),
+			ri.BuyTimestamp.Year(), int(ri.BuyTimestamp.Month()), ri.BuyTimestamp.Day(), ri.BuyValue.StringFixed(2),
+			ri.Fees.StringFixed(2), ri.Taxes.StringFixed(2), ri.BrokerCountry,
+		})
+	}
+
+	sumTxt := tr.Translate("sum", 1, nil)
+	// The footer lists one cell per column (13) so it never relies on
+	// go-pretty's implicit short-row padding; the trailing empty cell is the
+	// counter-country column, which has no total. Totals are formatted with
+	// StringFixed(2) so they match the two-decimal data rows.
+	tw.AppendFooter(table.Row{sumTxt, sumTxt, sumTxt, sumTxt, sumTxt, aw.TotalEarned().StringFixed(2), "", "", "", aw.TotalSpent().StringFixed(2), aw.TotalFees().StringFixed(2), aw.TotalTaxes().StringFixed(2), ""}, table.RowConfig{AutoMerge: true, AutoMergeAlign: text.AlignRight})
+
+	return tw
+}
+
+func colEuros(n int) table.ColumnConfig {
+	return table.ColumnConfig{
+		Number:           n,
+		Align:            text.AlignRight,
+		AlignFooter:      text.AlignRight,
+		AlignHeader:      text.AlignRight,
+		WidthMin:         WidthOther,
+		WidthMax:         WidthEuros,
+		WidthMaxEnforcer: truncateHeader,
+		Transformer: func(val any) string {
+			return fmt.Sprintf("%v €", val)
+		},
+		TransformerFooter: func(val any) string {
+			return fmt.Sprintf("%v €", val)
+		},
+	}
+}
+
+func colOther(n int) table.ColumnConfig {
+	return table.ColumnConfig{
+		Number:           n,
+		Align:            text.AlignLeft,
+		AlignFooter:      text.AlignLeft,
+		AlignHeader:      text.AlignLeft,
+		WidthMax:         WidthOther,
+		WidthMaxEnforcer: truncateHeader,
+	}
+}
+
+func colCountry(n int) table.ColumnConfig {
+	return table.ColumnConfig{
+		Number:           n,
+		Align:            text.AlignLeft,
+		AlignFooter:      text.AlignLeft,
+		AlignHeader:      text.AlignLeft,
+		WidthMax:         WidthCountry,
+		WidthMaxEnforcer: text.Trim,
+		Transformer: func(val any) string {
+			countryCode := val.(int64)
+			return fmt.Sprintf("%v - %s", val, countries.ByNumeric(int(countryCode)).Info().Name)
+		},
+	}
+}
+
+// truncateHeader enforces a column's WidthMax on terminal output by cutting
+// the text exactly at the width limit — mid-word if that is where it lands —
+// and marking the cut with an ellipsis: keeping as many leading runes
+// readable beats a tidy word boundary. All indexing is rune-based so
+// multibyte labels (e.g. Portuguese) truncate correctly.
+func truncateHeader(val string, width int) string {
+	runes := []rune(val)
+	if len(runes) <= width {
+		return val
+	}
+	// leave room for the ellipsis
+	limit := max(width-1, 1)
+	return string(runes[:limit]) + "…"
+}

internal/writing/internal/tabledef/table_test.go

@@ -0,0 +1,24 @@
+package tabledef
+
+import "testing"
+
+func TestTruncateHeader(t *testing.T) {
+	tests := []struct {
+		name  string
+		val   string
+		width int
+		want  string
+	}{
+		{name: "fits unchanged", val: "TAX PAID ABROAD", width: 15, want: "TAX PAID ABROAD"},
+		{name: "cut mid-word keeps the most runes", val: "EXPENSES AND CHARGES", width: 15, want: "EXPENSES AND C…"},
+		{name: "single overlong word is hard cut", val: "ESTRANGEIRO", width: 8, want: "ESTRANG…"},
+		{name: "cut ignores word boundaries", val: "IMPOSTO PAGO NO ESTRANGEIRO", width: 15, want: "IMPOSTO PAGO N…"},
+		{name: "multibyte runes count as one", val: "PAÍS DA CONTRAPARTE", width: 12, want: "PAÍS DA CON…"},
+		{name: "narrow width", val: "ABCD", width: 2, want: "A…"},
+	}
+	for _, tt := range tests {
+		if got := truncateHeader(tt.val, tt.width); got != tt.want {
+			t.Errorf("%s: truncateHeader(%q, %d) = %q, want %q", tt.name, tt.val, tt.width, got, tt.want)
+		}
+	}
+}

internal/writing/localizer.go

@@ -0,0 +1,52 @@
+package writing
+
+import (
+	"embed"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+
+	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"golang.org/x/text/language"
+)
+
+//go:embed translations/*.json
+var translationsFS embed.FS
+
+type Localizer struct {
+	*i18n.Localizer
+}
+
+func NewLocalizer(lang string) (*Localizer, error) {
+	bundle := i18n.NewBundle(language.English)
+	bundle.RegisterUnmarshalFunc("json", json.Unmarshal)
+
+	_, err := bundle.LoadMessageFileFS(translationsFS, "translations/en.json")
+	if err != nil {
+		return nil, fmt.Errorf("loading english messages: %w", err)
+	}
+
+	_, err = bundle.LoadMessageFileFS(translationsFS, "translations/pt.json")
+	if err != nil {
+		return nil, fmt.Errorf("loading portuguese messages: %w", err)
+	}
+
+	localizer := i18n.NewLocalizer(bundle, lang)
+
+	return &Localizer{
+		Localizer: localizer,
+	}, nil
+}
+
+func (t Localizer) Translate(key string, count int, values map[string]any) string {
+	txt, err := t.Localize(&i18n.LocalizeConfig{
+		MessageID:    key,
+		TemplateData: values,
+		PluralCount:  count,
+	})
+	if err != nil {
+		slog.Error("failed to translate message", slog.Any("err", err))
+		return "<ERROR>"
+	}
+	return txt
+}

internal/writing/localizer_test.go

@@ -0,0 +1,28 @@
+package writing_test
+
+import (
+	"testing"
+
+	"github.com/nmoniz/any2anexoj/internal/writing"
+)
+
+func TestNewLocalizer(t *testing.T) {
+	tests := []struct {
+		name string
+		lang string
+	}{
+		{"english", "en"},
+		{"portuguese", "pt"},
+		{"english with region", "en-US"},
+		{"portuguese with region", "pt-BR"},
+		{"unknown language falls back to default", "!!"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := writing.NewLocalizer(tt.lang)
+			if err != nil {
+				t.Fatalf("want success call but failed: %v", err)
+			}
+		})
+	}
+}

internal/writing/table/printer.go

@@ -0,0 +1,34 @@
+// Package table renders an internal.AggregatorWriter as the human-readable
+// Anexo J report table for the terminal. The shared table definition it (and
+// the html package) renders from lives in internal/writing/internal/tabledef.
+package table
+
+import (
+	"io"
+
+	"github.com/nmoniz/any2anexoj/internal"
+	"github.com/nmoniz/any2anexoj/internal/writing/internal/tabledef"
+)
+
+// Printer writes a simple, human readable, table to the provided io.Writer
+// for the report items in an AggregatorWriter. Each Render call builds a
+// fresh table from the aggregator, so invoking it repeatedly on the same
+// instance never duplicates rows.
+type Printer struct {
+	output     io.Writer
+	translator tabledef.Translator
+}
+
+func NewPrinter(w io.Writer, tr tabledef.Translator) *Printer {
+	return &Printer{
+		output:     w,
+		translator: tr,
+	}
+}
+
+// Render writes the terminal table for aw to the configured output.
+func (pp *Printer) Render(aw *internal.AggregatorWriter) {
+	t := tabledef.Build(pp.translator, aw)
+	t.SetOutputMirror(pp.output)
+	t.Render()
+}

internal/writing/table/printer_test.go

@@ -0,0 +1,84 @@
+package table_test
+
+import (
+	"bytes"
+	"testing"
+	"time"
+
+	"github.com/nmoniz/any2anexoj/internal"
+	"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
+	localizer, err := writing.NewLocalizer("en")
+	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 C… │ TAX PAID ABROAD │ COUNTER COUNTRY      │
+├───┼─────────────────────┼──────┼──────┼───────┼─────┼──────────────┼──────┼───────┼─────┼──────────────┼─────────────────┼─────────────────┼──────────────────────┤
+│ 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)
+	}
+}

internal/writing/translations/en.json

@@ -0,0 +1,54 @@
+{
+  "realization": {
+    "one": "Realization",
+    "other": "Realizations"
+  },
+  "acquisition": {
+    "one": "Acquisition",
+    "other": "Acquisitions"
+  },
+  "source_country": {
+    "one": "Source country",
+    "other": "Source countries"
+  },
+  "counter_country": {
+    "one": "Counter country",
+    "other": "Counter countries"
+  },
+  "year": {
+    "one": "Year",
+    "other": "Years"
+  },
+  "month": {
+    "one": "Month",
+    "other": "Months"
+  },
+  "day": {
+    "one": "Day",
+    "other": "Days"
+  },
+  "value": {
+    "one": "Value",
+    "other": "Values"
+  },
+  "code": {
+    "one": "Code",
+    "other": "Codes"
+  },
+  "expenses": {
+    "one": "Expense and charge",
+    "other": "Expenses and charges"
+  },
+  "foreign_tax_paid": {
+    "one": "Tax paid abroad",
+    "other": "Taxes paid abroad"
+  },
+  "sum": {
+    "one": "Sum",
+    "other": "Sums"
+  },
+  "report_title": {
+    "one": "Tax report",
+    "other": "Tax reports"
+  }
+}

internal/writing/translations/pt.json

@@ -0,0 +1,54 @@
+{
+  "realization": {
+    "one": "Realização",
+    "other": "Realizações"
+  },
+  "acquisition": {
+    "one": "Aquisição",
+    "other": "Aquisições"
+  },
+  "source_country": {
+    "one": "País da fonte",
+    "other": "Países da fonte"
+  },
+  "counter_country": {
+    "one": "País da contraparte",
+    "other": "Países da contraparte"
+  },
+  "year": {
+    "one": "Ano",
+    "other": "Anos"
+  },
+  "month": {
+    "one": "Mês",
+    "other": "Meses"
+  },
+  "day": {
+    "one": "Dia",
+    "other": "Dias"
+  },
+  "value": {
+    "one": "Valor",
+    "other": "Valores"
+  },
+  "code": {
+    "one": "Código",
+    "other": "Códigos"
+  },
+  "expenses": {
+    "one": "Despesa e encargo",
+    "other": "Despesas e encargos"
+  },
+  "foreign_tax_paid": {
+    "one": "Imposto pago no estrangeiro",
+    "other": "Impostos pagos no estrangeiro"
+  },
+  "sum": {
+    "one": "Soma",
+    "other": "Somas"
+  },
+  "report_title": {
+    "one": "Relatório fiscal",
+    "other": "Relatórios fiscais"
+  }
+}