package system

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

// Role repository data struct
type GroupMemberRepo struct {
	engine *xorm.Engine
}

// New role repository instance
func NewGroupMemberRepo(engine *xorm.Engine) *GroupMemberRepo {
	return &GroupMemberRepo{
		engine: engine,
	}
}

// Get role by id
func (d *GroupMemberRepo) GetById(ocId int64, gmId int64) *datamodels.GroupMember {
	data := &datamodels.GroupMember{GmId: gmId}
	ok, err := d.engine.Get(data)
	if ok && err == nil {
		return data
	} else {
		data.GroupId = 0
		return data
	}
}

func (d *GroupMemberRepo) GetList(m map[string]interface{})([]viewmodels.GroupMemberInfo, error) {
    ocId      := m["ocId"].(int64)
	keywords  := m["keywords"].(string)
	sqlSelect := `SELECT A.gm_id,
                         A.group_id,
                         A.group_name,
                         A.account_id,
                         A.group_member_remark `
	sqlFrom   := `FROM      s_group_member AS A
                  LEFT JOIN s_group        AS B ON (A.group_id = B.group_id) `
	sqlWhere  := `WHERE  A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)
	if keywords != "" {
		sqlWhere += ` AND   B.group_name like ` + "'%" + keywords + "%'"
	}
	datalist := make([]viewmodels.GroupMemberInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("group_id DESC").Find(&datalist)
	if err != nil {
		return nil, err
	}

	return datalist, nil
}

func (d *GroupMemberRepo) GetMembersOfSubordinateGroupByPage(ocId, groupId, groupLeft, groupRight int64, keyword string) []viewmodels.GroupMemberInfo {
	var datalist = make([]viewmodels.GroupMemberInfo, 0)

	sqlSelect := `
        SELECT
            DISTINCT(A.account_id),
            A.gm_id,
            A.oc_id,
            A.group_id,
            A.created_by,
            A.created_time,
            A.updated_by,
            A.updated_time,
            A.deleted_flag,
            A.deleted_by,
            A.deleted_time,
    
            B.account_name,
            B.account_real_name,
            B.account_phone,
            B.account_pic,
            B.status,    
            C.group_name,
            C.node_left,
            C.node_right,

            D.gmp_id,
            D.position_id,
            D.position_name,
			
			E.gmpg_id,
            E.grant_group_id,
            F.group_name as grant_group_name

        `
	sqlFrom := `
        FROM
            s_group_member                      AS A
        LEFT JOIN account                       AS B ON (A.oc_id = B.oc_id AND A.account_id = B.account_id)
        LEFT JOIN s_group                       AS C ON (A.oc_id = C.oc_id AND A.group_id    = C.group_id)
        LEFT JOIN s_group_member_position_grant AS E ON (B.oc_id = E.oc_id AND B.account_id = E.account_id)
        LEFT JOIN s_group                       AS F ON(E.oc_id = F.oc_id AND E.grant_group_id = F.group_id)
        LEFT JOIN (
            SELECT
                M.oc_id,
                M.account_id,
                M.gmp_id,
                M.group_id,
                M.position_id,
                P.position_name,
                N.gmpg_id,
                N.grant_group_id,
                GP.group_name as grant_group_name
            FROM
                s_group_member_position AS M
            LEFT JOIN s_group_member_position_grant AS N ON (
                    M.oc_id = N.oc_id
                AND M.account_id = N.account_id
                AND M.group_id = N.group_id
                AND M.position_id = N.position_id)
            LEFT JOIN s_position AS P  ON(M.oc_id = P.oc_id  AND M.position_id    = P.position_id)
            LEFT JOIN s_group    AS GP ON(M.oc_id = GP.oc_id AND N.grant_group_id = GP.group_id)
         )      AS  D ON (A.oc_id= D.oc_id AND A.account_id = D.account_id AND A.group_id = D.group_id)
                 `
	sqlWhere := `WHERE  B.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)

	if keyword != "" {
		sqlWhere += ` AND ( B.account_real_name LIKE ` + "'%" + keyword + "%'"
		sqlWhere += ` OR B.account_name             LIKE ` + "'%" + keyword + "%'"
		sqlWhere += ` OR B.account_phone            LIKE ` + "'%" + keyword + "%'"
		sqlWhere += ` OR D.position_title           LIKE ` + "'%" + keyword + "%'"
	}

	if groupLeft > 0 && groupRight > 0 {
		sqlWhere += ` AND C.node_left  >= ` + fmt.Sprintf("%d", groupLeft)
		sqlWhere += ` AND C.node_right <= ` + fmt.Sprintf("%d", groupRight)
	}

	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("A.group_id DESC").Find(&datalist)
	if err != nil {
		log.Fatal(err)
	}

	return datalist
}

func (d *GroupMemberRepo) GetFirstGroupByAccountId(ocId int64, aid int64) (*viewmodels.GroupMemberInfo, error) {
	var groupMemberInfo = &viewmodels.GroupMemberInfo{}

	sqlSelect := `
        SELECT
            A.gm_id,
            A.oc_id,
            A.account_id,
            A.group_id,
            B.group_name,
            B.node_left,
            B.node_right
        `
	sqlFrom := `
        FROM
            s_group_member    AS A
        LEFT JOIN s_group     AS B ON (A.oc_id = B.oc_id AND A.group_id    = B.group_id)
        `
	sqlWhere := ` WHERE  A.oc_id      = ` + fmt.Sprintf("%d", ocId)
	sqlWhere += ` AND    A.account_id = ` + fmt.Sprintf("%d", aid)

	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("A.group_id DESC").Limit(1).Get(groupMemberInfo)
	if !has || err != nil {
		log.Fatal(err)
		return nil, err
	}

	return groupMemberInfo, nil
}

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

// Update
func (d *GroupMemberRepo) Update(ocId int64, gmId int64, data *datamodels.GroupMember) error {
	_, err := d.engine.Where("oc_id = ?", ocId).Where("gm_id =?", gmId).Update(data)
	return err
}

// Delete
func (d *GroupMemberRepo) Delete(ocId int64, gmId int64) error {
	_, err := d.engine.Where("oc_id = ?", ocId).Where("gm_id =?", gmId).Delete(new(datamodels.GroupMember))
	return err
}

// Delete
func (d *GroupMemberRepo) DeleteByGroupId(ocId int64, groupId int64) error {
	_, err := d.engine.Where("oc_id = ?", ocId).
		Where("group_id = ?", groupId).
		Delete(new(datamodels.GroupMember))

	return err
}

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