package turso

import (
	"database/sql"
	"log"

	"trankilou.fr/lassistanoque/backend/internal/adapter/database/orm"
	"trankilou.fr/lassistanoque/backend/internal/domain"
)

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

func NewTursoUserRepository(db *sql.DB) *TursoUserRepository {
	dialect := orm.NewSqliteDialect()
	userTable, err := orm.NewTable[domain.User](db, dialect, "users")
	if err != nil {
		log.Fatalf("error creating lasebuche user table")
	}
	teamTable, err := orm.NewTable[domain.Team](db, dialect, "teams")
	if err != nil {
		log.Fatalf("error creating lasebuche team table")
	}
	userTeamTable, err := orm.NewTable[domain.UserTeam](db, dialect, "user_teams")
	if err != nil {
		log.Fatalf("error creating lasebuche team table")
	}
	userAddressTable, err := orm.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.Select()
}

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.Select(
		orm.WithWhere("id in (select team_id from user_teams where user_id=$1)", userid),
		orm.WithOrder("label asc"),
	)
}

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.Select(
		orm.WithWhere("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) ListUserAddresses(id string) ([]*domain.UserAddress, error) {
	return ur.AddressTable.Select(
		orm.WithWhere("user_id=$1", id),
		orm.WithOrder("type asc"),
	)
}

func (ur *TursoUserRepository) GetUserAddress(addrID string) (*domain.UserAddress, error) {
	return ur.AddressTable.Get(addrID)
}

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