package data

import (
	"context"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

type User struct {
	Id              uint      `json:"id" gorm:"primarykey;autoincrement"`
	UUID            uuid.UUID `json:"uuid" gorm:"type:uuid;uniqueindex;not null"`
	UserId          uuid.UUID `json:"user_id" gorm:"type:uuid;uniqueindex;not null"`
	Email           string    `json:"email" gorm:"type:varchar(255);uniqueindex;not null"`
	Username        string    `json:"username" gorm:"type:varchar(255);uniqueindex;not null"`
	Nickname        string    `json:"nickname" gorm:"type:text"`
	Subtitle        string    `json:"subtitle" gorm:"type:text"`
	Avatar          string    `json:"avatar" gorm:"type:text"`
	Bio             string    `json:"bio" gorm:"type:text"`
	PermissionLevel uint      `json:"permission_level" gorm:"default:10;not null"`
	AllowPublic     bool      `json:"allow_public" gorm:"default:false;not null"`
}

type UserIndexDoc struct {
	UserId   string `json:"user_id"`
	Email    string `json:"email"`
	Username string `json:"username"`
	Type     string `json:"type"`
	Nickname string `json:"nickname"`
	Subtitle string `json:"subtitle"`
	Avatar   string `json:"avatar"`
}

func (self *User) SetEmail(s string) *User {
	self.Email = s
	return self
}

func (self *User) SetUsername(s string) *User {
	self.Username = s
	return self
}

func (self *User) SetNickname(s string) *User {
	self.Nickname = s
	return self
}

func (self *User) SetSubtitle(s string) *User {
	self.Subtitle = s
	return self
}

func (self *User) SetAvatar(s string) *User {
	self.Avatar = s
	return self
}

func (self *User) SetBio(s string) *User {
	self.Bio = s
	return self
}

func (self *User) SetPermissionLevel(s uint) *User {
	self.PermissionLevel = s
	return self
}

func (self *User) SetAllowPublic(s bool) *User {
	self.AllowPublic = s
	return self
}

func (self *User) GetByEmail(ctx context.Context, email *string) (*User, error) {
	var user User

	err := Database.WithContext(ctx).
		Where("email = ?", email).
		First(&user).Error

	if err != nil {
		return nil, err
	}

	return &user, nil
}

func (self *User) GetByUserId(ctx context.Context, userId *uuid.UUID) (*User, error) {
	var user User

	err := Database.WithContext(ctx).
		Where("user_id = ?", userId).
		First(&user).Error

	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		}
		return nil, err
	}

	return &user, err
}

func (self *User) Create(ctx context.Context) error {
	self.UUID = uuid.New()
	self.UserId = uuid.New()

	// DB transaction only
	if err := Database.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(self).Error; err != nil {
			return err
		}
		return nil
	}); err != nil {
		return err
	}

	return nil
}

func (self *User) UpdateByUserID(ctx context.Context, userId *uuid.UUID, updates map[string]any) error {
	return Database.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		if err := tx.Model(&User{}).
			Where("user_id = ?", userId).
			Updates(updates).Error; err != nil {
			return err
		}

		var updatedUser User
		if err := tx.Where("user_id = ?", userId).First(&updatedUser).Error; err != nil {
			return err
		}
		return nil
	})
}

func (self *User) FastListUsers(ctx context.Context, limit, offset *int) (*[]UserIndexDoc, error) {
	var results []UserIndexDoc

	query := Database.WithContext(ctx).Model(&User{})

	err := query.Select("user_id", "email", "username", "nickname", "subtitle", "avatar").
		Limit(*limit).
		Offset(*offset).
		Scan(&results).Error

	if err != nil {
		return nil, err
	}

	return &results, nil
}