package persistence

import (
	domainInvite "RenewCMS/internal/domain/invite"
	domainUser "RenewCMS/internal/domain/user"
	"RenewCMS/internal/infrastructure/persistence/mappers"
	entity "RenewCMS/internal/infrastructure/persistence/models"
	"time"

	"gorm.io/gorm"
)

type InviteRepository struct {
	db *gorm.DB
}

func NewInviteRepository(db *gorm.DB) *InviteRepository {
	return &InviteRepository{db}
}

func (i *InviteRepository) Create(invite domainInvite.Invite) (domainInvite.Invite, error) {
	model := mappers.InviteToModel(invite)
	model.ID = 0
	if err := i.db.Create(&model).Error; err != nil {
		return domainInvite.Invite{}, err
	}

	return mappers.InviteToDomain(model), nil
}

func (i *InviteRepository) GetAll() []domainInvite.Invite {
	var invites []entity.Invite
	i.db.Model(&entity.Invite{}).Find(&invites)

	var domainInvites []domainInvite.Invite
	for _, localInvite := range invites {
		domainInvites = append(domainInvites, mappers.InviteToDomain(localInvite))
	}

	return domainInvites
}

func (i *InviteRepository) Delete(id uint32) error {
	result := i.db.Delete(&entity.Invite{}, id)
	return deleteOrNotFound(result, domainInvite.ErrInviteNotFound)
}

func (i *InviteRepository) Renew(id uint32, hashedCode string, expiresAt time.Time, createdAt time.Time) (domainInvite.Invite, error) {
	query := i.db.Model(&entity.Invite{})
	query = query.Where("id = ? AND accepted_at IS NULL", id)
	result := query.Updates(map[string]any{
		"hashed_code": hashedCode,
		"expires_at":  expiresAt,
		"created_at":  createdAt,
	})
	if err := deleteOrNotFound(result, domainInvite.ErrInviteNotFound); err != nil {
		return domainInvite.Invite{}, err
	}

	var model entity.Invite
	if err := i.db.First(&model, id).Error; err != nil {
		return domainInvite.Invite{}, err
	}
	return mappers.InviteToDomain(model), nil
}

func (i *InviteRepository) AcceptWithUser(inviteID uint32, acceptedAt time.Time, newUser domainUser.User) (domainUser.User, error) {
	createdModel := mappers.UserToModel(newUser)
	err := i.db.Transaction(func(tx *gorm.DB) error {
		query := tx.Model(&entity.Invite{})
		query = query.Where("id = ? AND accepted_at IS NULL", inviteID)
		marked := query.Update("accepted_at", acceptedAt)
		if err := deleteOrNotFound(marked, domainInvite.ErrInviteNotFound); err != nil {
			return err
		}
		return tx.Create(&createdModel).Error
	})
	if err != nil {
		return domainUser.User{}, err
	}

	return mappers.UserToDomain(createdModel), nil
}

var _ domainInvite.Repository = &InviteRepository{}