package repositories

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

type AppPermitRepo struct {
	engine *xorm.Engine
}

func NewAppPermitRepo(engine *xorm.Engine) *AppPermitRepo {
	return &AppPermitRepo{
		engine: engine,
	}
}

func (d *AppPermitRepo) GetList(m map[string]interface{})([]viewmodel.AppPermitInfo, error) {
	sqlSelect := ` SELECT A.app_id,
                          B.app_title,
                          A.role_id,
                          A.permit_id,
                          A.permit_title,
                          A.permit_code,
                          A.permit_desc,
                          A.permit_type,
                          A.root_id,
                          A.parent_id,
                          A.sort_no     `
	sqlFrom   := ` FROM   app_permit  AS A
                   JOIN   app         AS B ON (A.app_id = B.app_id) `
	sqlWhere  := ` WHERE  A.deleted_flag = 0 `
	if appKey, ok := m["appKey"]; ok {
		sqlWhere +=  " AND B.app_key = '" + fmt.Sprintf("%s", appKey) + "'"
	}
	if appId, ok := m["appId"]; ok {
		sqlWhere += " AND A.app_id = " + fmt.Sprintf("%d", appId)
	}
	if roleId, ok := m["roleId"]; ok {
		sqlWhere += " AND A.role_id = " + fmt.Sprintf("%d", roleId)
	}
	if keywords, ok := m["keywords"]; ok {
		sqlWhere += " AND A.permit_title like '%" + fmt.Sprintf("%s", keywords) + "%'"
	}
	sqlOrderBy := " ORDER BY A.app_id, A.role_id, A.parent_id, A.sort_no "
	
	datalist := make([]viewmodel.AppPermitInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *AppPermitRepo) GetListById(appId, roleId int64)([]viewmodel.AppPermitInfo, error) {
	sqlSelect := ` SELECT A.app_id,
                          B.app_title,
                          A.role_id,
                          A.permit_id,
                          A.permit_title,
                          A.permit_code,
                          A.permit_desc,
                          A.permit_type,
                          A.root_id,
                          A.parent_id,
                          A.sort_no     `
	sqlFrom   := ` FROM   app_permit  AS A
                   JOIN   app         AS B ON (A.app_id = B.app_id) `
	sqlWhere  := ` WHERE  A.deleted_flag = 0 `
	sqlWhere  += fmt.Sprintf(" AND A.app_id = %d ", appId)
	sqlWhere  += fmt.Sprintf(" AND A.role_id = %d ", roleId)
	
	sqlOrderBy := " ORDER BY A.app_id, A.role_id, A.parent_id, A.sort_no "
	
	datalist := make([]viewmodel.AppPermitInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *AppPermitRepo) GetListByKey(appKey string, roleId int64)([]viewmodel.AppPermitInfo, error) {
	sqlSelect := ` SELECT A.app_id,
                          A.role_id,
                          A.permit_id,
                          A.permit_title,
                          A.permit_code,
                          A.permit_desc,
                          A.permit_type,
                          A.root_id,
                          A.parent_id,
                          A.sort_no     `
	sqlFrom   := ` FROM  app_permit  AS A
                   JOIN  app         AS B ON (A.app_id = B.app_id) `
	sqlWhere  := ` WHERE A.deleted_flag = 0 `
	sqlWhere  += ` AND B.app_key = '` + appKey + "'"
	sqlWhere  += ` AND A.role_id =  ` + fmt.Sprintf("%d", roleId)
	sqlOrderBy := " ORDER BY A.app_id, A.role_id, A.parent_id, A.sort_no "
	
	datalist := make([]viewmodel.AppPermitInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *AppPermitRepo) GetById(appId, roleId, permitId int64)(*viewmodel.AppPermitInfo, error) {
	sqlSelect := ` SELECT A.app_id,
                          A.role_id,
                          A.permit_id,
                          A.permit_title,
                          A.permit_code,
                          A.permit_desc,
                          A.permit_type,
                          A.root_id,
                          A.parent_id,
                          A.sort_no     `
	sqlFrom   := ` FROM   app_permit  AS A
                   JOIN   app         AS B ON (A.app_id = B.app_id) `
	sqlWhere  := ` WHERE A.deleted_flag = 0 `
	sqlWhere  += fmt.Sprintf(" AND A.app_id    = %d ", appId)
	sqlWhere  += fmt.Sprintf(" AND A.role_id   = %d ", roleId)
	sqlWhere  += fmt.Sprintf(" AND A.permit_id = %d ", permitId)
	
	data := &viewmodel.AppPermitInfo{}
	_, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(data)
	if err != nil {
		return nil, err
	} else {
		return data, nil
	}
}

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

func (d *AppPermitRepo) Update(data *datamodel.AppPermit) error {
	appId    := data.AppId
	roleId   := data.RoleId
	permitId := data.PermitId
	_, err := d.engine.
		Where("app_id = ?", appId).
		Where("role_id = ?", roleId).
		Where("permit_id = ?", permitId).
		Update(data)
	return err
}

func (d *AppPermitRepo) Delete(appId, roleId, permitId int64) error {
	data := &datamodel.AppPermit{}
	_, err := d.engine.
		Where("app_id = ?", appId).
		Where("role_id = ?", roleId).
		Where("permit_id = ?", permitId).
		Delete(data)
	return err
}