package app

import (
	"context"
	"errors"
	"fmt"
	"strings"

	"github.com/jackc/pgx/v5"
	"golang.org/x/crypto/bcrypt"
)

// User is an authenticated account. A user always belongs to one subscriber.
type User struct {
	ID           int64
	SubscriberID int64
	Email        string
	Name         string
}

// Subscriber is a tenant. The internal subscriber (is_internal=true) sees the
// admin/CMS view; every other subscriber sees the customer dashboard.
type Subscriber struct {
	ID         int64
	Name       string
	IsInternal bool
}

var errNoCredentials = errors.New("invalid email or password")

func normEmail(email string) string {
	return strings.ToLower(strings.TrimSpace(email))
}

// authenticate verifies an email/password pair and returns the user.
func (a *App) authenticate(ctx context.Context, email, password string) (User, error) {
	var u User
	var hash string
	err := a.pool.QueryRow(ctx,
		`SELECT id, subscriber_id, email, name, password_hash FROM users WHERE email = $1`,
		normEmail(email),
	).Scan(&u.ID, &u.SubscriberID, &u.Email, &u.Name, &hash)
	if errors.Is(err, pgx.ErrNoRows) {
		return User{}, errNoCredentials
	}
	if err != nil {
		return User{}, err
	}
	if hash == "" || bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)) != nil {
		return User{}, errNoCredentials
	}
	return u, nil
}

func (a *App) subscriber(ctx context.Context, id int64) (Subscriber, error) {
	var s Subscriber
	err := a.pool.QueryRow(ctx,
		`SELECT id, name, is_internal FROM subscribers WHERE id = $1`, id,
	).Scan(&s.ID, &s.Name, &s.IsInternal)
	return s, err
}

// InitAdmin ensures the internal subscriber exists and creates or updates the
// first admin user under it. Used by the `spread init-admin` subcommand.
func (a *App) InitAdmin(ctx context.Context, email, password string) error {
	if len(password) < 8 {
		return fmt.Errorf("password must be at least 8 characters")
	}
	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return err
	}

	tx, err := a.pool.Begin(ctx)
	if err != nil {
		return err
	}
	defer tx.Rollback(ctx)

	var subID int64
	err = tx.QueryRow(ctx, `SELECT id FROM subscribers WHERE is_internal = TRUE ORDER BY id LIMIT 1`).Scan(&subID)
	if errors.Is(err, pgx.ErrNoRows) {
		if err = tx.QueryRow(ctx,
			`INSERT INTO subscribers (name, is_internal) VALUES ('Spread (internal)', TRUE) RETURNING id`,
		).Scan(&subID); err != nil {
			return err
		}
	} else if err != nil {
		return err
	}

	_, err = tx.Exec(ctx,
		`INSERT INTO users (subscriber_id, email, password_hash, name)
		 VALUES ($1, $2, $3, 'Admin')
		 ON CONFLICT (email) DO UPDATE SET password_hash = EXCLUDED.password_hash, subscriber_id = EXCLUDED.subscriber_id`,
		subID, normEmail(email), string(hash),
	)
	if err != nil {
		return err
	}
	return tx.Commit(ctx)
}

// OpenAndInitAdmin is a convenience for the init-admin subcommand.
func OpenAndInitAdmin(ctx context.Context, dsn, email, password string) error {
	a, err := Open(ctx, Config{DSN: dsn})
	if err != nil {
		return err
	}
	defer a.Close()
	return a.InitAdmin(ctx, email, password)
}

func (a *App) findOrCreateSubscriber(ctx context.Context, name string) (int64, error) {
	var id int64
	err := a.pool.QueryRow(ctx,
		`SELECT id FROM subscribers WHERE name = $1 AND is_internal = FALSE ORDER BY id LIMIT 1`, name,
	).Scan(&id)
	if errors.Is(err, pgx.ErrNoRows) {
		return a.createSubscriber(ctx, name)
	}
	return id, err
}

// OpenAndCreateCustomer creates a customer user, making the named subscriber if
// it doesn't exist yet. Convenience for the create-customer subcommand.
func OpenAndCreateCustomer(ctx context.Context, dsn, email, subscriberName, password string) error {
	a, err := Open(ctx, Config{DSN: dsn})
	if err != nil {
		return err
	}
	defer a.Close()
	subID, err := a.findOrCreateSubscriber(ctx, subscriberName)
	if err != nil {
		return err
	}
	_, err = a.createUser(ctx, subID, email, "", password)
	return err
}