package xlstranslator

import (
	"io"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/xuri/excelize/v2"
)

func TestConvertFileConvertsRenamedUpload(t *testing.T) {
	src := filepath.Join("..", "..", "..", "..", "docs", "database", "grc_amortiguador_pesado.xlsx")
	if _, err := os.Stat(src); err != nil {
		t.Skipf("seed workbook not available: %v", err)
	}

	dir := t.TempDir()
	upload := filepath.Join(dir, "catalogo_sept2026.xlsx")
	if err := copyFile(src, upload); err != nil {
		t.Fatalf("copy seed workbook: %v", err)
	}

	outDir := t.TempDir()
	conv := NewConverter(Config{InputDir: dir, OutputDir: outDir})

	if err := conv.ConvertFile("amort", upload); err != nil {
		t.Fatalf("ConvertFile: %v", err)
	}

	out := filepath.Join(outDir, "amort-deseable.csv")
	data, err := os.ReadFile(out)
	if err != nil {
		t.Fatalf("expected output %s: %v", out, err)
	}
	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
	if len(lines) < 2 {
		t.Fatalf("expected header + data rows, got %d lines", len(lines))
	}
}

func TestConvertFileMalformedSheet(t *testing.T) {
	dir := t.TempDir()
	upload := filepath.Join(dir, "wrong_sheet.xlsx")
	f := excelize.NewFile()
	if err := f.SaveAs(upload); err != nil {
		t.Fatalf("save fixture: %v", err)
	}

	conv := NewConverter(Config{InputDir: dir, OutputDir: t.TempDir()})
	err := conv.ConvertFile("amort", upload)
	if err == nil {
		t.Fatal("expected malformation error")
	}
	if !strings.Contains(err.Error(), "archivo malformado") || !strings.Contains(err.Error(), "Sheet1") {
		t.Fatalf("error should warn about malformation and list available sheets, got: %v", err)
	}
}

func TestConvertFileUnknownType(t *testing.T) {
	conv := NewConverter(Config{InputDir: t.TempDir(), OutputDir: t.TempDir()})
	err := conv.ConvertFile("nope", "whatever.xlsx")
	if err == nil || !strings.Contains(err.Error(), "unknown converter name") {
		t.Fatalf("expected unknown converter error, got %v", err)
	}
}

func copyFile(src, dst string) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

	out, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, in)
	return err
}