package repositories

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

type GroupMemberRepo struct {
	engine *xorm.Engine
}

func NewGroupMemberRepo(engine *xorm.Engine) *GroupMemberRepo {
	return &GroupMemberRepo{
		engine: engine,
	}
}

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

func (d *GroupMemberRepo) GetList(m map[string]interface{})([]viewmodels.GroupMemberInfo, error) {
    ocId      := m["ocId"].(int64)
	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, ok := m["keywords"]; ok {
		sqlWhere += ` AND   B.group_name like ` + "'%" + fmt.Sprintf("%s", 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
	} else {
		return datalist, nil
	}
}

func (d *GroupMemberRepo) GetMembersOfSubordinateGroupByPage(m map[string]interface{})([]viewmodels.GroupMemberInfo, error){
	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)
		                 `
	
	ocId     := m["ocId"].(int64)
	sqlWhere := ` WHERE  B.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)

	if keywords, ok := m["keywords"]; ok {
		sqlWhere += ` AND ( B.account_real_name     LIKE ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
		sqlWhere += ` OR B.account_name             LIKE ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
		sqlWhere += ` OR B.account_phone            LIKE ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
		sqlWhere += ` OR D.position_title           LIKE ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
	}
	
	groupLeft,  ok1 := m["groupLeft"]
	groupRight, ok2 := m["groupRight"]
	if ok1 && ok2 {
		sqlWhere += ` AND C.node_left  >= ` + fmt.Sprintf("%d", groupLeft)
		sqlWhere += ` AND C.node_right <= ` + fmt.Sprintf("%d", groupRight)
	}
	
	datalist := make([]viewmodels.GroupMemberInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("A.group_id DESC").Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *GroupMemberRepo) GetFirstGroupByAccountId(ocId int64, aid int64) (*viewmodels.GroupMemberInfo, error) {
	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)
	
	groupMemberInfo := &viewmodels.GroupMemberInfo{}
	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("A.group_id DESC").Limit(1).Get(groupMemberInfo)
	if !has || err != nil {
		return nil, err
	} else {
		return groupMemberInfo, nil
	}
}

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

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

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

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

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