package core

import (
	"crypto/rand"
	"encoding/base64"
	"errors"

	"gorm.io/gorm"
)

func CreatePlan(db *gorm.DB, user *User, name string) (*Plan, error) {
	join_code := make([]byte, 32)
	_, err := rand.Read(join_code)
	if err != nil {
		return nil, err
	}

	var plan Plan = Plan{
		Name:  name,
		Owner: user.Username,
		Members: []Member{
			{
				UserID: user.Username,
				Type:   "user",
			},
		},
		JoinCode: base64.URLEncoding.EncodeToString(join_code),
	}
	result := db.Create(&plan)
	if result.Error != nil {
		return nil, result.Error
	}
	return &plan, nil
}

func GetPlan(orm *gorm.DB, id uint) (*Plan, error) {
	var plan Plan = Plan{
		ID: id,
	}
	result := orm.Take(&plan)

	if errors.Is(result.Error, gorm.ErrRecordNotFound) {
		return nil, ErrNotFound
	} else if result.Error != nil {
		return nil, result.Error
	}

	return &plan, nil
}

func (p *Plan) GetAllUsers(orm *gorm.DB) ([]Member, error) {
	var members []Member
	err := orm.Model(p).Association("Members").Find(&members)
	return members, err
}

func (p *Plan) IsMember(orm *gorm.DB, u *User) (bool, error) {
	var member_count int64
	result := orm.
		Table("members").
		Where("user_id=? AND plan_id=?", u.Username, p.ID).
		Count(&member_count).Error
	if result != nil {
		return false, ErrNotMember
	}
	return member_count == 1, nil
}

func (p *Plan) GetMember(orm *gorm.DB, u *User) (*Member, error) {
	var m Member
	result := orm.
		Table("members").
		Where("user_id=? AND plan_id=?", u.Username, p.ID).
		Take(&m).Error
	if result != nil {
		return nil, ErrNotMember
	}
	return &m, nil
}

func (p *Plan) HasNonUser(orm *gorm.DB, name string) (bool, error) {
	var member_count int64
	result := orm.
		Table("members").
		Where("plan_id=? AND name=?", p.ID, name).
		Count(&member_count).Error
	if result != nil {
		return false, result
	}
	return member_count == 1, nil
}

func (p *Plan) AddMember(orm *gorm.DB, new_member *Member) error {
	if new_member == nil {
		return errors.New("Member is nil")
	}
	new_member.PlanID = p.ID
	if new_member.Type == "non-user" {
		if new_member.Name == "" {
			return errors.New("name required for non user")
		}
		found, err := p.HasNonUser(orm, new_member.Name)
		if err != nil {
			return nil
		}
		if found {
			return errors.New("Non user name taken")
		}
		return orm.Create(&new_member).Error
	} else if new_member.Type == "user" {
		user, err := GetUser(orm, new_member.UserID)
		if err != nil {
			return err
		}

		found, err := p.IsMember(orm, &user)
		if err != nil {
			return nil
		}
		if found {
			return errors.New("User already is member")
		}

		return orm.Create(&new_member).Error
	} else {
		return errors.New("Invalid type for user")
	}
}