package db

import (
	"context"
	"fmt"
	"log"
	"net/http"

	"github.com/jackc/pgx/v5/pgxpool"
)

// db connection info
// !MIGHT CHANGE
const (
	host     = "localhost"
	port     = 5432
	user     = "asdfuser"
	password = "asdfpassword"
	dbname   = "asdfdb"
)

var DbPool *pgxpool.Pool
var allowedUsernames map[string]bool

// initialize connection to db
func ConnectToDb() (*pgxpool.Pool, error) {
	// this server is intended to be ran on the same system as the db
	dbUrl := fmt.Sprintf("postgresql://%s:%s@%s:%d/%s", user, password, host, port, dbname)
	config, err := pgxpool.ParseConfig((dbUrl))
	if err != nil {
		return nil, fmt.Errorf("unable to parse data URL: %w", err)
	}

	pool, err := pgxpool.NewWithConfig(context.Background(), config)
	if err != nil {
		return nil, fmt.Errorf("unable to create connection pool: %w", err)
	}

	log.Println("Connected to DB :)")
	return pool, nil
}

// setup demo db
func SetupDemoDb(w http.ResponseWriter, r *http.Request) {
	// create table and insert demo data
	createTableSQL := `
    CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        username VARCHAR(50) UNIQUE NOT NULL,
        email VARCHAR(100) NOT NULL
    );`

	// also avoid duplicate entries
	insertDataSQL := `
    INSERT INTO users (username, email) VALUES
        ('alice', 'alice@example.com'),
        ('bob', 'bob@example.com'),
        ('charlie', 'charlie@example.com')
		ON CONFLICT (username) DO NOTHING;`

	// execute create table
	_, err := DbPool.Exec(context.Background(), createTableSQL)
	if err != nil {
		http.Error(w, "Failed to create table", http.StatusInternalServerError)
		log.Printf("Error creating table: %v", err)
		return
	}

	// execute insert demo data
	_, err = DbPool.Exec(context.Background(), insertDataSQL)
	if err != nil {
		http.Error(w, "Failed to insert demo data", http.StatusInternalServerError)
		log.Printf("Error inserting demo data: %v", err)
		return
	}

	// response back to client
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("Database setup complete with demo data"))
	log.Println("Demo database setup completed successfully")
}

// nuke the db
func NukeDb(w http.ResponseWriter, r *http.Request) {
	// drop user table
	dropTableSQL := `
	DROP TABLE IF EXISTS users CASCADE;
	`

	// execute the command
	_, err := DbPool.Exec(context.Background(), dropTableSQL)
	if err != nil {
		http.Error(w, "Failed to drop table", http.StatusInternalServerError)
		log.Printf("Error dropping table: %v", err)
		return
	}

	log.Println("Database nuked")
}

// fetch existing usernames from db
func FetchUsernames() (map[string]bool, error) {
	usernames := make(map[string]bool)

	rows, err := DbPool.Query(context.Background(), "SELECT username FROM users")
	if err != nil {
		return nil, fmt.Errorf("error querying users: %w", err)
	}
	defer rows.Close()

	for rows.Next() {
		var username string
		if err := rows.Scan(&username); err != nil {
			return nil, fmt.Errorf("error scanning username: %w", err)
		}
		usernames[username] = true
	}

	log.Println("Fetched usernames:", usernames)
	return usernames, nil
}
