package sqlite

import (
	"context"
	"database/sql"
	"log"

	_ "modernc.org/sqlite"

	"uvok.de/go/training_fellow/registration"
)

var (
	debug bool = true
)

type SqliteRepository struct {
	FileName string
	context  context.Context
}

func NewRepository(fileName string, context context.Context) *SqliteRepository {
	repo := SqliteRepository{FileName: fileName, context: context}
	return &repo
}

func (repo *SqliteRepository) SaveRegistration(registration *registration.Registration) error {
	db, err := repo.checkInit()
	if err != nil {
		return err
	}
	defer db.Close()

	res, err := db.ExecContext(
		repo.context,
		`INSERT INTO registrations
		  (reg_id, first_name, last_name, email, company, training_code, date, privacy_policy_accepted, confirmed)
		  VALUES (?,?,?,?,?,?,?,?,?)`,
		registration.RegId,
		registration.FirstName,
		registration.LastName,
		registration.Email,
		registration.Company,
		registration.TrainingCode,
		registration.Date,
		registration.PrivacyPolicyAccepted,
		registration.Confirmed)

	if debug {
		log.Printf("SQL result: %v", res)
	}
	return err
}

func (repo *SqliteRepository) GetUnconfirmedRegistrations() ([]*registration.Registration, error) {
	db, err := repo.checkInit()
	if err != nil {
		return nil, err
	}
	res, err := db.QueryContext(
		repo.context,
		`SELECT reg_id, first_name, last_name, email, company, training_code, date, privacy_policy_accepted
		FROM registrations
		WHERE confirmed = 0
		`)

	if err != nil {
		return nil, err
	}
	defer res.Close()

	regArray := make([]*registration.Registration, 0)
	for res.Next() {
		reg := registration.Registration{}
		err = res.Scan(&reg.RegId, &reg.FirstName, &reg.LastName, &reg.Email, &reg.Company, &reg.TrainingCode, &reg.Date, &reg.PrivacyPolicyAccepted)
		if err != nil {
			log.Printf("Error scanning: %v", err)
		}
		regArray = append(regArray, &reg)
	}
	return regArray, nil
}

func (repo *SqliteRepository) ConfirmRegistration(registrationId string) (*registration.Registration, error) {
	repo.checkInit()
	panic("not implemented") // TODO: Implement
}

func (repo *SqliteRepository) checkInit() (*sql.DB, error) {
	db, err := sql.Open("sqlite", repo.FileName)
	if err != nil {
		return nil, err
	}
	err = db.PingContext(repo.context)

	if err != nil {
		return nil, err
	}
	return db, nil
}