package repository

import (
    "fmt"
    "xorm.io/core"
    "xorm.io/xorm"
    "xps/pkg/system/datamodel"
    "xps/pkg/system/viewmodel"
)

type RoleMemberRepo struct {
    engine *xorm.Engine
}

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

func (d *RoleMemberRepo) GetList(m map[string]interface{}) ([]viewmodel.RoleMemberInfo, error) {
    ocId := m["ocId"].(int64)

    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 keywords, ok := m["keywords"]; ok {
        sqlWhere += ` AND   B.role_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
    }

    datalist := make([]viewmodel.RoleMemberInfo, 0)
    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("role_id DESC").Find(&datalist)
    if err != nil {
        return nil, err
    } else {
        return datalist, nil
    }
}

func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64) (*viewmodel.RoleMemberInfo, error) {
    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)

    roleMemberInfo := &viewmodel.RoleMemberInfo{}
    has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(roleMemberInfo)
    if !has || err != nil {
        return nil, err
    } else {
        return roleMemberInfo, nil
    }
}

func (d *RoleMemberRepo) Update(ocId int64, rmId int64, rm *datamodel.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(datamodel.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(datamodel.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(datamodel.RoleMember))
    return err
}

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