//
// Created by vfs on 02.05.2024.
//

package main;

import "errors";
import "time";
import "golang.org/x/crypto/bcrypt";
import "database/sql";
import _ "github.com/lib/pq";
import "fmt";

import "github.com/stripe/stripe-go/v78";
import "github.com/stripe/stripe-go/v78/customer";

var ErrRoRecord           = errors.New("no matching record found");
var ErrInvalidCredentials = errors.New("invalid credentials");
var ErrDuplicateEmail     = errors.New("duplicate email");
var ErrDuplicateUsername  = errors.New("duplicate username");

type Account struct {
	Id int32;
	Username string;
	Password []byte;
	Color int32;
	Firstname string;
	Lastname string;
	Email string;
	Created time.Time;
	StripeID string;
}

type Usermodel struct {
	DB *sql.DB;
}

func (m *Usermodel) Insert(username string, password string, firstname string, lastname string, email string) error {


	hashedpassword, err := bcrypt.GenerateFromPassword([]byte(password), 12);
	stmt := `INSERT INTO accounts (username, password, firstname, lastname, email, created) VALUES ($1, $2, $3, $4, $5, NOW()) RETURNING id;`;

	var insertid int32;

	row := m.DB.QueryRow(stmt, username, string(hashedpassword), firstname, lastname, email);
	if row.Err() != nil {
		fmt.Println(row.Err());
		return row.Err();
	}

	err = row.Scan(&insertid);

	params := &stripe.CustomerParams{
		Name: stripe.String(fmt.Sprintf("%s %s", firstname, lastname)),
		Email: stripe.String(email),
	};
	customer, err := customer.New(params);

	stmt = `UPDATE accounts SET stripe_id = $1 WHERE id = $2;`;

	fmt.Println(customer.ID, insertid);

	_, err = m.DB.Exec(stmt, customer.ID, insertid);
	if err != nil {
		fmt.Println(err);
		return err;
	}

	return nil;
}

func (m *Usermodel) Delete(id int32) error {
	account, err := users.Get_account(id);

	if account.StripeID != "" {
		result, err := customer.Del(account.StripeID, nil);
		if err != nil {
			fmt.Println(err);
		}
		fmt.Println(result);
	}

	stmt := `DELETE FROM accounts WHERE id = $1;`;

	_, err = m.DB.Exec(stmt, id);
	if err != nil {
		fmt.Println(err);
	}


	return nil;
}

func (m *Usermodel) Get_account(id int32) (Account, error) {
	if id == 0 {
		return Account{}, nil;
	}
	stmt := `SELECT id, username, password, color, firstname, lastname, email, created, stripe_id FROM accounts WHERE id = $1;`;
	row := m.DB.QueryRow(stmt, id);

	var account Account;
	err := row.Scan(&account.Id, &account.Username, &account.Password, &account.Color, &account.Firstname, &account.Lastname, &account.Email, &account.Created, &account.StripeID);

	if err == sql.ErrNoRows {
		return Account{}, sql.ErrNoRows;
	} else if err != nil {
		return Account{}, err;
	}

	return account, nil;
}

func (m *Usermodel) Authenticate(username string, password string) (int32, error) {
	var id int32;
	var hashedpassword []byte;
	row := m.DB.QueryRow("SELECT id, password FROM accounts WHERE username = $1", username);
	err := row.Scan(&id, &hashedpassword);
	if err == sql.ErrNoRows {
		return 0, ErrInvalidCredentials;
	}

	err = bcrypt.CompareHashAndPassword(hashedpassword, []byte(password));
	if err == bcrypt.ErrMismatchedHashAndPassword {
		return 0, ErrInvalidCredentials;
	} else if err != nil {
		return 0, err;
	}

	return id, nil;
}

func (m *Usermodel) Exists_account(id int32) bool {
	var exists bool;
	stmt := `SELECT EXISTS(SELECT 1 FROM accounts WHERE id = $1);`;
	row := m.DB.QueryRow(stmt, id);
	if row.Err() != nil {
		fmt.Println(row.Err());
	}
	row.Scan(&exists);

	fmt.Println(exists);

	return exists;
}