package repository

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

type GroupRepo struct {
    engine *xorm.Engine
}

func NewGroupRepo(engine *xorm.Engine) *GroupRepo {
    return &GroupRepo{
        engine: engine,
    }
}

func (d *GroupRepo) GetById(ocId int64, groupId int64) (*viewmodel.GroupInfo, error) {

    sqlSelect := ` SELECT A.oc_id,
                          A.group_id ,
                          A.group_name,
                          A.group_cat_id,
                          B.group_cat_title,
                          A.group_code,
                          A.group_select,
                          A.group_path,
                          A.group_desc,
                          A.root_id,
                          A.parent_id,
                          C.group_name as parent_name,
                          A.node_left,
                          A.node_right,
                          A.node_level,
                          A.is_leaf,
                          A.is_fixed           `
    sqlFrom := ` FROM       s_group      AS A
                   LEFT JOIN  s_group_cat  AS B ON (A.oc_id = B.oc_id AND A.group_cat_id     = B.group_cat_id)
                   LEFT JOIN  s_group      AS C ON (A.oc_id = C.oc_id AND A.parent_id  = C.group_id )`
    sqlWhere := ` WHERE A.deleted_flag = 0 AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
    sqlWhere += ` AND   A.group_id = ` + fmt.Sprintf("%d", groupId)

    data := &viewmodel.GroupInfo{GroupId: groupId}
    ok, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("group_id ASC").Get(data)
    if !ok && err != nil {
        return nil, err
    } else {
        return data, nil
    }
}

func (d *GroupRepo) GetList(m map[string]interface{}) ([]viewmodel.GroupInfo, error) {
    sqlSelect := ` SELECT A.oc_id,
                          A.group_id ,
                          A.group_name,
                          A.group_cat_id,
                          B.group_cat_title,
                          A.group_code,
                          A.group_select,
                          A.group_path,
                          A.group_desc,
                          A.root_id,
                          A.parent_id,
                          C.group_name as parent_name,
                          A.node_left,
                          A.node_right,
                          A.node_level,
                          A.is_leaf,
                          A.is_fixed           `
    sqlFrom := ` FROM       s_group      AS A
                  LEFT JOIN  s_group_cat  AS B ON (A.oc_id = B.oc_id AND A.group_cat_id     = B.group_cat_id)
                  LEFT JOIN  s_group      AS C ON (A.oc_id = C.oc_id AND A.parent_id  = C.group_id )`

    ocId := m["ocId"].(int64)
    sqlWhere := ` WHERE A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)
    if keywords, ok := m["keywords"]; ok {
        sqlWhere += ` AND A.group_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
    }

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

func (d *GroupRepo) GetAll(ocId int64) ([]viewmodel.GroupInfo, error) {
    sqlSelect := ` SELECT A.oc_id,
                          A.group_id ,
                          A.group_name,
                          A.group_cat_id,
                          B.group_cat_title,
                          A.group_code,
                          A.group_select,
                          A.group_path,
                          A.group_desc,
                          A.root_id,
                          A.parent_id,
                          C.group_name as parent_name,
                          A.node_left,
                          A.node_right,
                          A.node_level,
                          A.is_leaf,
                          A.is_fixed           `
    sqlFrom := ` FROM       s_group      AS A
                  LEFT JOIN  s_group_cat  AS B ON (A.oc_id = B.oc_id AND A.group_cat_id     = B.group_cat_id)
                  LEFT JOIN  s_group      AS C ON (A.oc_id = C.oc_id AND A.parent_id  = C.group_id )`

    sqlWhere := ` WHERE A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)

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

func (d *GroupRepo) Delete(m map[string]interface{}) error {
    ocId := m["ocId"].(int64)
    groupId := m["groupId"].(int64)
    deletedBy := m["deletedBy"].(int64)

    group := &datamodel.Group{}
    group.OcId = ocId
    group.GroupId = groupId
    group.DeletedFlag = 1
    group.DeletedBy = deletedBy
    group.DeletedAt = time.Now()
    _, err := d.engine.Where("oc_id = ?", ocId).Where("group_id =?", groupId).Update(group)
    return err
}

func (d *GroupRepo) Update(data *datamodel.Group) error {
    ocId := data.OcId
    groupId := data.GroupId
    _, err := d.engine.Where("oc_id = ?", ocId).Where("group_id =?", groupId).Update(data)
    return err
}

func (d *GroupRepo) RefreshLeafStatus(ocId int64, groupId int64, isLeaf bool) error {
    var sql string
    if isLeaf {
        sql = fmt.Sprintf("UPDATE s_group SET is_leaf = 1 WHERE oc_id = %d AND group_id = %d", ocId, groupId)
    } else {
        sql = fmt.Sprintf("UPDATE s_group SET is_leaf = 0 WHERE oc_id = %d AND group_id = %d", ocId, groupId)
    }
    _, err := d.engine.Exec(sql)
    return err
}

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

func (d *GroupRepo) IncrementGroupLeft(ocId int64, steps int64, nodeLeft int64) error {
    sql := fmt.Sprintf("UPDATE s_group SET node_left = node_left + %d  WHERE oc_id =%d AND node_left >= %d AND deleted_flag = 0", steps, ocId, nodeLeft)
    _, err := d.engine.Exec(sql)

    return err
}

func (d *GroupRepo) IncrementGroupRight(ocId int64, steps int64, nodeRight int64) error {
    sql := fmt.Sprintf("UPDATE s_group SET node_right = node_right + %d WHERE oc_id =%d AND node_right >= %d AND deleted_flag = 0", steps, ocId, nodeRight)
    _, err := d.engine.Exec(sql)
    return err
}

func (d *GroupRepo) DecrementGroupLeft(ocId int64, steps int64, nodeLeft int64) error {
    sql := fmt.Sprintf("UPDATE s_group SET node_left = node_left - %d  WHERE oc_id =%d AND node_left > %d AND deleted_flag = 0", steps, ocId, nodeLeft)
    _, err := d.engine.Exec(sql)
    return err
}

func (d *GroupRepo) DecrementGroupRight(ocId int64, steps int64, nodeRight int64) error {
    sql := fmt.Sprintf("UPDATE s_group SET node_right = node_right - %d WHERE oc_id =%d AND node_right > %d AND deleted_flag = 0", steps, ocId, nodeRight)
    _, err := d.engine.Exec(sql)
    return err
}

func (d *GroupRepo) BatchDelete(ocId, nodeLeft, nodeRight int64) error {
    sql := fmt.Sprintf("DELETE FROM s_group WHERE oc_id = %d AND node_left >= %d AND node_right <= %d ", ocId, nodeLeft, nodeRight)
    _, err := d.engine.Exec(sql)
    return err
}

func (d *GroupRepo) CountOfChildren(ocId, groupId int64) (int64, error) {
    count, err := d.engine.Where("oc_id = ?", ocId).
        Where("group_parent_id = ?", groupId).
        Where("deleted_flag = 0 ").
        Count(new(datamodel.Group))

    if err != nil {
        return 0, err
    }
    return count, nil
}