package system

import (
	"fmt"
	"log"
	"xorm.io/core"
	"xorm.io/xorm"
	"xps/datamodels"
	"xps/viewmodels"
)

type RoleMemberRepo struct {
	engine *xorm.Engine
}

func NewRoleMemberRepo(engine *xorm.Engine) *RoleMemberRepo {
	return &RoleMemberRepo{
		engine: engine,
	}
}

func (d *RoleMemberRepo) GetAll(ocId int64, keyword string) []viewmodels.RoleMemberInfo {
	var datalist = make([]viewmodels.RoleMemberInfo, 0)
	
	sqlSelect := `SELECT A.rm_id,
                         A.role_id,
                         B.role_name,
                         A.account_id,
                         C.account_name `
	sqlFrom := `FROM      s_role_member AS A 
                  LEFT JOIN s_role        AS B ON (A.role_id    = B.role_id)
                  LEFT JOIN account       AS C ON (A.account_id = C.account_id AND A.oc_id = C.oc_id)
                 `
	sqlWhere := `WHERE A.oc_id = ` + fmt.Sprintf("%d", ocId)
	
	if keyword != "" {
		sqlWhere += ` AND   B.role_name like ` + "'%" + keyword + "%'"
	}
	
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("role_id DESC").Find(&datalist)
	if err != nil {
		log.Fatal(err)
	}
	
	return datalist
}

func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64) (*viewmodels.RoleMemberInfo, error) {
	var roleMemberInfo = &viewmodels.RoleMemberInfo{}
	
	sqlSelect := `SELECT A.rm_id,
                         A.role_id,
                         B.role_name,
                         A.account_id,
                         C.account_name  `
	sqlFrom := `  FROM      s_role_member AS A
                  LEFT JOIN s_role        AS B ON (A.role_id    = B.role_id)
                  LEFT JOIN account       AS C ON (A.account_id = C.account_id AND A.oc_id = C.oc_id) 
                 `
	sqlWhere := `WHERE A.oc_id      = ` + fmt.Sprintf("%d", ocId)
	sqlWhere += `  AND A.account_id = ` + fmt.Sprintf("%d", accountId)
	
	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(roleMemberInfo)
	if !has || err != nil {
		return nil, err
	}
	
	return roleMemberInfo, nil
}

func (d *RoleMemberRepo) Update(ocId int64, rmId int64, rm *datamodels.RoleMember) error {
	_, err := d.engine.Where("oc_id = ?", ocId).
		Where("rm_id  = ?", rmId).
		Update(rm)
	return err
}

func (d *RoleMemberRepo) Delete(ocId int64, rmId int64) error {
	_, err := d.engine.Where("oc_id = ?", ocId).
		Where("rm_id  = ?", rmId).
		Delete(new(datamodels.RoleMember))
	return err
}

func (d *RoleMemberRepo) DeleteById(ocId int64, roleId int64, accountId int64) error {
	_, err := d.engine.ID(core.PK{ocId, roleId, accountId}).Delete(new(datamodels.RoleMember))
	return err
}

func (d *RoleMemberRepo) DeleteByAccountId(ocId int64, accountId int64) error {
	_, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("account_id  = ?", accountId).
		Delete(new(datamodels.RoleMember))
	return err
}

func (d *RoleMemberRepo) Create(data *datamodels.RoleMember) error {
	_, err := d.engine.Insert(data)
	return err
}