package turso

import (
	"database/sql"
	"log"

	"trankilou.fr/lassistanoque/backend/internal/domain"

	"gitea.trankilou.fr/fabien/lasebuche"
)

type TursoUserRepository struct {
	DB            *sql.DB
	UserTable     lasebuche.Table[domain.User]
	TeamTable     lasebuche.Table[domain.Team]
	UserTeamTable lasebuche.Table[domain.UserTeam]
	AddressTable  lasebuche.Table[domain.UserAddress]
}

func NewTursoUserRepository(db *sql.DB) *TursoUserRepository {
	dialect := lasebuche.NewSqliteDialect()
	userTable, err := lasebuche.NewTable[domain.User](db, dialect, "users")
	if err != nil {
		log.Fatalf("error creating lasebuche user table")
	}
	teamTable, err := lasebuche.NewTable[domain.Team](db, dialect, "teams")
	if err != nil {
		log.Fatalf("error creating lasebuche team table")
	}
	userTeamTable, err := lasebuche.NewTable[domain.UserTeam](db, dialect, "user_teams")
	if err != nil {
		log.Fatalf("error creating lasebuche team table")
	}
	userAddressTable, err := lasebuche.NewTable[domain.UserAddress](db, dialect, "user_addresses")
	if err != nil {
		log.Fatalf("error creating lasebuche team table")
	}
	return &TursoUserRepository{
		DB:            db,
		UserTable:     userTable,
		TeamTable:     teamTable,
		UserTeamTable: userTeamTable,
		AddressTable:  userAddressTable,
	}
}

func (ur *TursoUserRepository) FindUser(id string) (*domain.User, error) {
	return ur.UserTable.Get(id)
}

func (ur *TursoUserRepository) FindUserByEmail(email string) (*domain.User, error) {
	return ur.UserTable.SelectOne("email=$1", email)
}

func (ur *TursoUserRepository) ListUsers() ([]*domain.User, error) {
	return ur.UserTable.SelectWhere("")
}

func (ur *TursoUserRepository) CreateUser(user *domain.User) (*domain.User, error) {
	return ur.UserTable.Insert(user)
}

func (ur *TursoUserRepository) UpdateUser(user *domain.User) (*domain.User, error) {
	return ur.UserTable.Update(user)
}

func (ur *TursoUserRepository) DeleteUser(id string) error {
	return ur.UserTable.Delete(id)
}

func (ur *TursoUserRepository) FindTeam(userid string, teamid string) (*domain.Team, error) {
	return ur.TeamTable.SelectOne("id=$1 and user_id=$2", teamid, userid)
}

func (ur *TursoUserRepository) ListTeams(userid string) ([]*domain.Team, error) {
	return ur.TeamTable.SelectWhere("user_id=$1", userid)
}

func (ur *TursoUserRepository) CreateTeam(userid string, team *domain.Team) (*domain.Team, error) {
	// TODO : gérér dans une transaction
	// TODO : déplacer dans le service
	team, err := ur.TeamTable.Insert(team)
	if err != nil {
		return nil, err
	}
	userTeam := &domain.UserTeam{
		UserID:        userid,
		TeamID:        team.ID,
		Administrator: true,
	}
	_, err = ur.UserTeamTable.Insert(userTeam)
	if err != nil {
		return nil, err
	}
	return team, nil
}

func (ur *TursoUserRepository) UpdateTeam(userid string, team *domain.Team) (*domain.Team, error) {
	return ur.TeamTable.Update(team)
}

func (ur *TursoUserRepository) DeleteTeam(userid string, teamid string) error {
	return ur.TeamTable.Delete(teamid)
}

func (ur *TursoUserRepository) FindUserTeam(userid string, teamid string) (*domain.UserTeam, error) {
	return ur.UserTeamTable.SelectOne("team_id=$1 and user_id=$2", teamid, userid)
}

func (ur *TursoUserRepository) ListUserTeams(userid string) ([]*domain.UserTeam, error) {
	return ur.UserTeamTable.SelectWhere("user_id=$1", userid)
}

func (ur *TursoUserRepository) CreateUserTeam(userid string, team *domain.UserTeam) (*domain.UserTeam, error) {
	return ur.UserTeamTable.Insert(team)
}

func (ur *TursoUserRepository) UpdateUserTeam(userid string, team *domain.UserTeam) (*domain.UserTeam, error) {
	return ur.UserTeamTable.Update(team)
}

func (ur *TursoUserRepository) DeleteUserTeam(userid string, teamid string) error {
	return ur.UserTeamTable.Delete(teamid)
}

func (ur *TursoUserRepository) PopulateUserWithTeams(user *domain.User) (*domain.UserWithTeams, error) {
	return nil, nil
}

func (ur *TursoUserRepository) ListUserAddresses(id string) ([]*domain.UserAddress, error) {
	return ur.AddressTable.SelectWhere("user_id=$1", id)
}

func (ur *TursoUserRepository) CreateUserAddress(userid string, addr *domain.UserAddress) (*domain.UserAddress, error) {
	addr.UserID = userid
	return ur.AddressTable.Insert(addr)
}
func (ur *TursoUserRepository) UpdateUserAddress(userid string, addr *domain.UserAddress) (*domain.UserAddress, error) {
	return ur.AddressTable.Update(addr)
}
func (ur *TursoUserRepository) DeleteUserAddress(userid string, addrID string) error {
	return ur.AddressTable.DeleteWhere("id=$1 and user_id=$2", addrID, userid)
}