package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/gofrs/uuid/v5"
	_ "github.com/jackc/pgx/v5/stdlib"
	"github.com/jmoiron/sqlx"
	"golang.org/x/crypto/bcrypt"

	"github.com/saveinmed/backend-go/internal/config"
	"github.com/saveinmed/backend-go/internal/domain"
)

const (
	seederSuperadminName     = "SaveInMed Superadmin"
	seederSuperadminUsername = "superadmin"
	seederSuperadminEmail    = "superadmin@saveinmed.com"
	seederSuperadminPassword = "sim-seeder-superadmin"
)

func main() {
	cfg, err := config.Load()
	if err != nil {
		log.Fatalf("failed to load config: %v", err)
	}

	db, err := sqlx.Open("pgx", cfg.DatabaseURL)
	if err != nil {
		log.Fatalf("Failed to connect to DB: %v", err)
	}
	defer db.Close()

	if err := db.Ping(); err != nil {
		log.Fatalf("Failed to ping DB: %v", err)
	}

	ctx := context.Background()

	log.Println("🧹 Cleaning database...")
	cleanDB(ctx, db)

	log.Println("🌱 Seeding data...")
	seedData(ctx, db, *cfg)

	log.Println("✅ Seeding complete!")
}

func cleanDB(ctx context.Context, db *sqlx.DB) {
	tables := []string{
		"reviews", "shipments", "payment_preferences", "orders", "order_items",
		"cart_items", "products", "companies", "users", "shipping_settings",
	}

	for _, table := range tables {
		_, err := db.ExecContext(ctx, fmt.Sprintf("TRUNCATE TABLE %s CASCADE", table))
		if err != nil {
			// Ignore error if table doesn't exist or is empty
			log.Printf("Warning cleaning %s: %v", table, err)
		}
	}
}

func seedData(ctx context.Context, db *sqlx.DB, cfg config.Config) {
	// 1. Seed platform superadmin
	adminCompanyID := uuid.Must(uuid.NewV7())
	createCompany(ctx, db, &domain.Company{
		ID:            adminCompanyID,
		CNPJ:          "00000000000000",
		CorporateName: "SaveInMed Platform",
		Category:      "platform",
		LicenseNumber: "SUPERADMIN",
		IsVerified:    true,
	})
	createUser(ctx, db, &domain.User{
		CompanyID:  adminCompanyID,
		Role:       "superadmin",
		Name:       seederSuperadminName,
		Username:   seederSuperadminUsername,
		Email:      seederSuperadminEmail,
		Superadmin: true,
	}, seederSuperadminPassword, cfg.PasswordPepper)

	// 2. Distributors (Sellers - SP Center)
	distributor1ID := uuid.Must(uuid.NewV7())
	createCompany(ctx, db, &domain.Company{
		ID:            distributor1ID,
		CNPJ:          "11111111000111",
		CorporateName: "Distribuidora Nacional",
		Category:      "distribuidora",
		LicenseNumber: "DIST-001",
		IsVerified:    true,
		Latitude:      -23.55052,
		Longitude:     -46.633308,
	})
	createUser(ctx, db, &domain.User{
		CompanyID: distributor1ID,
		Role:      "Owner",
		Name:      "Dono da Distribuidora",
		Username:  "distribuidora",
		Email:     "distribuidora@saveinmed.com",
	}, "123456", cfg.PasswordPepper)
	createShippingSettings(ctx, db, distributor1ID, -23.55052, -46.633308, "Rua da Distribuidora, 1000")

	// 2b. Second Distributor (Sellers - SP East Zone/Mooca)
	distributor2ID := uuid.Must(uuid.NewV7())
	createCompany(ctx, db, &domain.Company{
		ID:            distributor2ID,
		CNPJ:          "55555555000555",
		CorporateName: "Distribuidora Leste Ltda",
		Category:      "distribuidora",
		LicenseNumber: "DIST-002",
		IsVerified:    true,
		Latitude:      -23.55952,
		Longitude:     -46.593308,
	})
	createUser(ctx, db, &domain.User{
		CompanyID: distributor2ID,
		Role:      "Owner",
		Name:      "Gerente Leste",
		Username:  "distribuidora_leste",
		Email:     "leste@saveinmed.com",
	}, "123456", cfg.PasswordPepper)
	createShippingSettings(ctx, db, distributor2ID, -23.55952, -46.593308, "Rua da Mooca, 500")

	// 3. Pharmacies (Buyers)
	pharmacy1ID := uuid.Must(uuid.NewV7())
	createCompany(ctx, db, &domain.Company{
		ID:            pharmacy1ID,
		CNPJ:          "22222222000122",
		CorporateName: "Farmácia Central",
		Category:      "farmacia",
		LicenseNumber: "FARM-001",
		IsVerified:    true,
		Latitude:      -23.56052,
		Longitude:     -46.643308,
	})
	createUser(ctx, db, &domain.User{
		CompanyID: pharmacy1ID,
		Role:      "Owner",
		Name:      "Dono da Farmácia",
		Username:  "farmacia",
		Email:     "farmacia@saveinmed.com",
	}, "123456", cfg.PasswordPepper)

	pharmacy2ID := uuid.Must(uuid.NewV7())
	createCompany(ctx, db, &domain.Company{
		ID:            pharmacy2ID,
		CNPJ:          "33333333000133",
		CorporateName: "Drogarias Tiete",
		Category:      "farmacia",
		LicenseNumber: "FARM-002",
		IsVerified:    true,
		Latitude:      -23.51052,
		Longitude:     -46.613308,
	})
	createUser(ctx, db, &domain.User{
		CompanyID: pharmacy2ID,
		Role:      "Owner",
		Name:      "Gerente Tiete",
		Username:  "farmacia2",
		Email:     "tiete@saveinmed.com",
	}, "123456", cfg.PasswordPepper)

	// 4. Products
	// List of diverse products
	commonMeds := []struct {
		Name  string
		Price int64 // Base price
	}{
		{"Dipirona Sódica 500mg", 450},
		{"Paracetamol 750mg", 600},
		{"Ibuprofeno 400mg", 1100},
		{"Amoxicilina 500mg", 2200},
		{"Omeprazol 20mg", 1400},
		{"Simeticona 40mg", 700},
		{"Dorflex 36cp", 1850},
		{"Neosaldina 30dg", 2100},
		{"Torsilax 30cp", 1200},
		{"Cimegripe 20caps", 1300},
		{"Losartana Potássica 50mg", 800},
		{"Atenolol 25mg", 950},
		{"Metformina 850mg", 750},
		{"Sildenafila 50mg", 1500},
		{"Azitromicina 500mg", 2800},
	}

	var productIDs []uuid.UUID

	// Seed products for Dist 1
	for i, p := range commonMeds {
		id := uuid.Must(uuid.NewV7())
		// expiry := time.Now().AddDate(1, 0, 0)

		// Vary price slightly
		finalPrice := p.Price + int64(i*10) - 50
		if finalPrice < 100 {
			finalPrice = 100
		}

		createProduct(ctx, db, &domain.Product{
			ID:          id,
			SellerID:    distributor1ID,
			Name:        p.Name,
			Description: "Medicamento genérico de alta qualidade (Nacional)",
			// Batch/ExpiresAt/Stock removed
			PriceCents: finalPrice,
		})

		// Keep first 5 for orders
		if i < 5 {
			productIDs = append(productIDs, id)
		}
	}

	// Seed products for Dist 2 (Leste) - Only some of them, different prices
	for i, p := range commonMeds {
		if i%2 == 0 {
			continue
		} // Skip half

		id := uuid.Must(uuid.NewV7())
		// expiry := time.Now().AddDate(0, 6, 0) // Removed

		// Cheaper but fewer stock
		finalPrice := p.Price - 100
		if finalPrice < 100 {
			finalPrice = 100
		}

		createProduct(ctx, db, &domain.Product{
			ID:          id,
			SellerID:    distributor2ID,
			Name:        p.Name,
			Description: "Distribuição exclusiva ZL",
			// Batch/ExpiresAt/Stock removed
			PriceCents: finalPrice,
		})
	}

	// 5. Orders
	// Order 1: Pharmacy 1 buying from Dist 1
	orderID := uuid.Must(uuid.NewV7())
	totalCents := int64(0)

	// Items
	qty := int64(10)
	priceItem := productIDs[0] // Dipirona from Dist 1
	// We need to fetch price ideally but we know logic... let's just reuse base logic approx or fetch from struct above
	// Simulating price:
	unitPrice := commonMeds[0].Price - 50 // Same logic as above: p.Price + 0*10 - 50

	itemTotal := unitPrice * qty
	totalCents += itemTotal

	createOrder(ctx, db, &domain.Order{
		ID:         orderID,
		BuyerID:    pharmacy1ID,
		SellerID:   distributor1ID,
		Status:     "Faturado", // Ready for "Confirmar Entrega" test
		TotalCents: totalCents,
		CreatedAt:  time.Now().AddDate(0, 0, -2),
		UpdatedAt:  time.Now(),
	})

	createOrderItem(ctx, db, &domain.OrderItem{
		ID:        uuid.Must(uuid.NewV7()),
		OrderID:   orderID,
		ProductID: priceItem,
		Quantity:  qty,
		UnitCents: unitPrice,
		Batch:     "BATCH-NAC-" + priceItem.String()[:4],
		ExpiresAt: time.Now().AddDate(1, 0, 0),
	})

	// Order 2: Pharmacy 2 buying from Dist 1 (Pending)
	order2ID := uuid.Must(uuid.NewV7())
	createOrder(ctx, db, &domain.Order{
		ID:         order2ID,
		BuyerID:    pharmacy2ID,
		SellerID:   distributor1ID,
		Status:     "Pendente",
		TotalCents: 5000,
		CreatedAt:  time.Now(),
		UpdatedAt:  time.Now(),
	})

}

func createCompany(ctx context.Context, db *sqlx.DB, c *domain.Company) {
	now := time.Now().UTC()
	c.CreatedAt = now
	c.UpdatedAt = now
	_, err := db.NamedExecContext(ctx, `
		INSERT INTO companies (id, cnpj, corporate_name, category, license_number, is_verified, latitude, longitude, created_at, updated_at)
		VALUES (:id, :cnpj, :corporate_name, :category, :license_number, :is_verified, :latitude, :longitude, :created_at, :updated_at)
	`, c)
	if err != nil {
		log.Printf("Error creating company %s: %v", c.CorporateName, err)
	}
}

func createUser(ctx context.Context, db *sqlx.DB, u *domain.User, password, pepper string) {
	hashed, _ := bcrypt.GenerateFromPassword([]byte(password+pepper), bcrypt.DefaultCost)
	u.ID = uuid.Must(uuid.NewV7())
	u.PasswordHash = string(hashed)
	u.CreatedAt = time.Now().UTC()
	u.UpdatedAt = time.Now().UTC()

	// Ensure email/username uniqueness is handled by DB constraint, usually we just insert
	_, err := db.NamedExecContext(ctx, `
		INSERT INTO users (id, company_id, role, name, username, email, password_hash, email_verified, created_at, updated_at)
		VALUES (:id, :company_id, :role, :name, :username, :email, :password_hash, :email_verified, :created_at, :updated_at)
	`, u)
	if err != nil {
		log.Printf("Error creating user %s: %v", u.Username, err)
	}
}

func createProduct(ctx context.Context, db *sqlx.DB, p *domain.Product) {
	now := time.Now().UTC()
	p.CreatedAt = now
	p.UpdatedAt = now
	_, err := db.NamedExecContext(ctx, `
		INSERT INTO products (id, seller_id, name, description, price_cents, created_at, updated_at)
		VALUES (:id, :seller_id, :name, :description, :price_cents, :created_at, :updated_at)
	`, p)
	if err != nil {
		log.Printf("Error creating product %s: %v", p.Name, err)
	}
}

func createShippingSettings(ctx context.Context, db *sqlx.DB, vendorID uuid.UUID, lat, lng float64, address string) {
	now := time.Now().UTC()
	settings := &domain.ShippingSettings{
		VendorID:                   vendorID,
		Active:                     true,
		MaxRadiusKm:                50,
		PricePerKmCents:            150,  // R$ 1.50
		MinFeeCents:                1000, // R$ 10.00
		FreeShippingThresholdCents: nil,
		PickupActive:               true,
		PickupAddress:              address,
		PickupHours:                "Seg-Sex 08-18h",
		CreatedAt:                  now,
		UpdatedAt:                  now,
		Latitude:                   lat,
		Longitude:                  lng,
	}

	_, err := db.NamedExecContext(ctx, `
		INSERT INTO shipping_settings (
			vendor_id, active, max_radius_km, price_per_km_cents, min_fee_cents, 
			free_shipping_threshold_cents, pickup_active, pickup_address, pickup_hours, 
			latitude, longitude, created_at, updated_at
		) VALUES (
			:vendor_id, :active, :max_radius_km, :price_per_km_cents, :min_fee_cents,
			:free_shipping_threshold_cents, :pickup_active, :pickup_address, :pickup_hours,
			:latitude, :longitude, :created_at, :updated_at
		)
	`, settings)
	if err != nil {
		log.Printf("Error creating shipping settings: %v", err)
	}
}

func createOrder(ctx context.Context, db *sqlx.DB, o *domain.Order) {
	_, err := db.NamedExecContext(ctx, `
		INSERT INTO orders (id, buyer_id, seller_id, status, total_cents, created_at, updated_at)
		VALUES (:id, :buyer_id, :seller_id, :status, :total_cents, :created_at, :updated_at)
	`, o)
	if err != nil {
		log.Printf("Error creating order: %v", err)
	}
}

func createOrderItem(ctx context.Context, db *sqlx.DB, item *domain.OrderItem) {
	_, err := db.NamedExecContext(ctx, `
		INSERT INTO order_items (id, order_id, product_id, quantity, unit_cents, batch, expires_at)
		VALUES (:id, :order_id, :product_id, :quantity, :unit_cents, :batch, :expires_at)
	`, item)
	if err != nil {
		log.Printf("Error creating order item: %v", err)
	}
}