export.go

package main

import (
	"encoding/csv"
	"encoding/json"
	"fmt"
	"os"
	"time"

	"github.com/brianvoe/gofakeit/v7"
)

// UserRecord is the structured export type for JSON marshalling
type UserRecord struct {
	ID        int       `json:"id"`
	FirstName string    `json:"first_name"`
	LastName  string    `json:"last_name"`
	Email     string    `json:"email"`
	Phone     string    `json:"phone"`
	Company   string    `json:"company"`
	JobTitle  string    `json:"job_title"`
	Address   string    `json:"address"`
	City      string    `json:"city"`
	Country   string    `json:"country"`
	CreatedAt time.Time `json:"created_at"`
	Status    string    `json:"status"`
}

// runExport generates mock data directly to a file in the requested format
func runExport(format string, rowCount int, outputPath string) error {
	f, err := os.Create(outputPath)
	if err != nil {
		return fmt.Errorf("failed to create output file: %w", err)
	}
	defer f.Close()

	faker := gofakeit.New(uint64(time.Now().UnixNano()))

	switch format {
	case "csv":
		return exportCSV(f, rowCount, faker)
	case "json":
		return exportJSON(f, rowCount, faker)
	case "sql":
		return exportSQL(f, rowCount, faker)
	default:
		return fmt.Errorf("unsupported format: %q (use csv, json, or sql)", format)
	}
}

func exportCSV(w *os.File, rowCount int, faker *gofakeit.Faker) error {
	writer := csv.NewWriter(w)
	defer writer.Flush()

	header := []string{"id", "first_name", "last_name", "email", "phone", "company", "job_title", "address", "city", "country", "created_at", "status"}
	if err := writer.Write(header); err != nil {
		return err
	}

	for i := 0; i < rowCount; i++ {
		row := generateUserRow(i, faker)
		createdAt := row[10].(time.Time).Format("2006-01-02 15:04:05")

		record := []string{
			fmt.Sprintf("%d", row[0].(int)),
			row[1].(string),
			row[2].(string),
			row[3].(string),
			row[4].(string),
			row[5].(string),
			row[6].(string),
			row[7].(string),
			row[8].(string),
			row[9].(string),
			createdAt,
			row[11].(string),
		}
		if err := writer.Write(record); err != nil {
			return err
		}
	}
	return nil
}

func exportJSON(w *os.File, rowCount int, faker *gofakeit.Faker) error {
	encoder := json.NewEncoder(w)

	for i := 0; i < rowCount; i++ {
		row := generateUserRow(i, faker)
		record := UserRecord{
			ID:        row[0].(int),
			FirstName: row[1].(string),
			LastName:  row[2].(string),
			Email:     row[3].(string),
			Phone:     row[4].(string),
			Company:   row[5].(string),
			JobTitle:  row[6].(string),
			Address:   row[7].(string),
			City:      row[8].(string),
			Country:   row[9].(string),
			CreatedAt: row[10].(time.Time),
			Status:    row[11].(string),
		}
		if err := encoder.Encode(record); err != nil {
			return err
		}
	}
	return nil
}

func exportSQL(w *os.File, rowCount int, faker *gofakeit.Faker) error {
	createTable := `CREATE TABLE IF NOT EXISTS users (
    id INT PRIMARY KEY,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    email VARCHAR(150),
    phone VARCHAR(20),
    company VARCHAR(100),
    job_title VARCHAR(100),
    address VARCHAR(200),
    city VARCHAR(100),
    country VARCHAR(100),
    created_at TIMESTAMP,
    status VARCHAR(20)
);

`
	if _, err := w.WriteString(createTable); err != nil {
		return err
	}

	// Multi-row INSERTs in batches of 1000 for performance
	batchSize := 1000
	for batchStart := 0; batchStart < rowCount; batchStart += batchSize {
		batchEnd := batchStart + batchSize
		if batchEnd > rowCount {
			batchEnd = rowCount
		}

		if _, err := w.WriteString("INSERT INTO users (id, first_name, last_name, email, phone, company, job_title, address, city, country, created_at, status) VALUES\n"); err != nil {
			return err
		}

		for i := batchStart; i < batchEnd; i++ {
			row := generateUserRow(i, faker)
			createdAt := row[10].(time.Time).Format("2006-01-02 15:04:05")

			line := fmt.Sprintf("(%d, '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s', '%s')",
				row[0].(int),
				escapeSQL(row[1].(string)),
				escapeSQL(row[2].(string)),
				escapeSQL(row[3].(string)),
				escapeSQL(row[4].(string)),
				escapeSQL(row[5].(string)),
				escapeSQL(row[6].(string)),
				escapeSQL(row[7].(string)),
				escapeSQL(row[8].(string)),
				escapeSQL(row[9].(string)),
				createdAt,
				row[11].(string),
			)

			if i < batchEnd-1 {
				line += ",\n"
			} else {
				line += ";\n\n"
			}

			if _, err := w.WriteString(line); err != nil {
				return err
			}
		}
	}
	return nil
}

// escapeSQL doubles single quotes for safe SQL string literals
func escapeSQL(s string) string {
	result := ""
	for _, r := range s {
		if r == '\'' {
			result += "''"
		} else {
			result += string(r)
		}
	}
	return result
}