package repository

import (
	"context"
	"database/sql"
	"errors"
	"fmt"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/jackc/pgx/v5/pgtype"
)

func (s *Store) CreateUser(ctx context.Context, user domain.User, usedOtpId int64) (domain.User, error) {
	err := s.queries.MarkOtpAsUsed(ctx, usedOtpId)
	if err != nil {
		return domain.User{}, err
	}
	userRes, err := s.queries.CreateUser(ctx, dbgen.CreateUserParams{
		FirstName: user.FirstName,
		LastName:  user.LastName,
		Email: pgtype.Text{
			String: user.Email,
			Valid:  user.Email != "",
		},
		PhoneNumber: pgtype.Text{
			String: user.PhoneNumber,
			Valid:  user.PhoneNumber != "",
		},
		Password:      user.Password,
		Role:          string(user.Role),
		EmailVerified: user.EmailVerified,
		PhoneVerified: user.PhoneVerified,
	})
	if err != nil {
		return domain.User{}, err
	}
	return domain.User{
		ID:          userRes.ID,
		FirstName:   userRes.FirstName,
		LastName:    userRes.LastName,
		Email:       userRes.Email.String,
		PhoneNumber: userRes.PhoneNumber.String,
		Role:        domain.Role(userRes.Role),
	}, nil
}
func (s *Store) GetUserByID(ctx context.Context, id int64) (domain.User, error) {
	user, err := s.queries.GetUserByID(ctx, id)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return domain.User{}, domain.ErrUserNotFound
		}
		return domain.User{}, err
	}
	return domain.User{
		ID:            user.ID,
		FirstName:     user.FirstName,
		LastName:      user.LastName,
		Email:         user.Email.String,
		PhoneNumber:   user.PhoneNumber.String,
		Role:          domain.Role(user.Role),
		EmailVerified: user.EmailVerified,
		Password:      user.Password,
		PhoneVerified: user.PhoneVerified,
		CreatedAt:     user.CreatedAt.Time,
		UpdatedAt:     user.UpdatedAt.Time,
		SuspendedAt:   user.SuspendedAt.Time,
		Suspended:     user.Suspended,
	}, nil
}
func (s *Store) GetAllUsers(ctx context.Context) ([]domain.User, error) {
	users, err := s.queries.GetAllUsers(ctx)
	if err != nil {
		return nil, err
	}
	userList := make([]domain.User, len(users))
	for i, user := range users {
		userList[i] = domain.User{
			ID:          user.ID,
			FirstName:   user.FirstName,
			LastName:    user.LastName,
			Email:       user.Email.String,
			PhoneNumber: user.PhoneNumber.String,
			Role:        domain.Role(user.Role),
		}
	}
	return userList, nil
}
func (s *Store) UpdateUser(ctx context.Context, user domain.UpdateUserReq) error {
	err := s.queries.UpdateUser(ctx, dbgen.UpdateUserParams{
		// ID:          user.ID,
		// FirstName:   user.FirstName,
		// LastName:    user.LastName,
		// Email:       user.Email,
		// PhoneNumber: user.PhoneNumber,
	})
	if err != nil {
		return err
	}
	return nil
}
func (s *Store) DeleteUser(ctx context.Context, id int64) error {
	err := s.queries.DeleteUser(ctx, id)
	if err != nil {
		return err
	}
	return nil
}
func (s *Store) CheckPhoneEmailExist(ctx context.Context, phoneNum, email string) (bool, bool, error) {
	fmt.Printf("phoneNum: %s, email: %s\n", phoneNum, email)
	row, err := s.queries.CheckPhoneEmailExist(ctx, dbgen.CheckPhoneEmailExistParams{
		PhoneNumber: pgtype.Text{
			String: phoneNum,
			Valid:  phoneNum != "",
		},
		Email: pgtype.Text{
			String: email,

			Valid: email != "",
		},
	})
	fmt.Printf("row: %+v\n", row)
	if err != nil {
		return false, false, err
	}
	return row.EmailExists, row.PhoneExists, nil
}

func (s *Store) GetUserByEmail(ctx context.Context, email string) (domain.User, error) {
	user, err := s.queries.GetUserByEmail(ctx, pgtype.Text{
		String: email,
		Valid:  true,
	})
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return domain.User{}, domain.ErrUserNotFound
		}
		return domain.User{}, err
	}
	return domain.User{
		ID:          user.ID,
		FirstName:   user.FirstName,
		LastName:    user.LastName,
		Email:       user.Email.String,
		PhoneNumber: user.PhoneNumber.String,
		Role:        domain.Role(user.Role),
	}, nil
}
func (s *Store) GetUserByPhone(ctx context.Context, phoneNum string) (domain.User, error) {
	user, err := s.queries.GetUserByPhone(ctx, pgtype.Text{
		String: phoneNum,
		Valid:  true,
	})
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return domain.User{}, domain.ErrUserNotFound
		}
		return domain.User{}, err
	}
	return domain.User{
		ID:          user.ID,
		FirstName:   user.FirstName,
		LastName:    user.LastName,
		Email:       user.Email.String,
		PhoneNumber: user.PhoneNumber.String,
		Role:        domain.Role(user.Role),
	}, nil
}

func (s *Store) UpdatePassword(ctx context.Context, identifier string, password []byte, usedOtpId int64) error {
	err := s.queries.MarkOtpAsUsed(ctx, usedOtpId)
	if err != nil {
		return err
	}
	err = s.queries.UpdatePassword(ctx, dbgen.UpdatePasswordParams{
		Password: password,
		Email: pgtype.Text{
			String: identifier,
			Valid:  true,
		},
		PhoneNumber: pgtype.Text{
			String: identifier,
			Valid:  true,
		},
	})
	if err != nil {
		return err
	}
	return nil
}