package models

import (
	sql2 "database/sql"
	"eta/eta_api/global"
	"eta/eta_api/utils"
	"fmt"
	"strings"
	"time"
)

type EnCompanyPermission struct {
	EnCompanyPermissionId int       `gorm:"column:en_company_permission_id;primaryKey;primaryKey" description:"英文品种权限ID"`
	EnCompanyId           int       `description:"英文客户ID"`
	EnPermissionId        int       `description:"英文品种ID"`
	CreateTime            time.Time `description:"创建时间"`
}

var EnCompanyPermissionColumns = struct {
	EnCompanyPermissionId string
	EnCompanyId           string
	EnPermissionId        string
	CreateTime            string
}{
	EnCompanyPermissionId: "en_company_permission_id",
	EnCompanyId:           "en_company_id",
	EnPermissionId:        "en_permission_id",
	CreateTime:            "create_time",
}

func (m *EnCompanyPermission) TableName() string {
	return "en_company_permission"
}

func (m *EnCompanyPermission) Create() (err error) {
	err = global.DbMap[utils.DbNameReport].Create(m).Error
	return
}

func (m *EnCompanyPermission) Update(cols []string) (err error) {
	err = global.DbMap[utils.DbNameReport].Select(cols).Updates(m).Error
	return
}

func (m *EnCompanyPermission) Del() (err error) {
	sql := fmt.Sprintf(`DELETE FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), EnCompanyPermissionColumns.EnCompanyPermissionId)
	err = global.DbMap[utils.DbNameReport].Exec(sql, m.EnCompanyPermissionId).Error
	return
}

func (m *EnCompanyPermission) GetItemById(id int) (item *EnCompanyPermission, err error) {
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE %s = ? LIMIT 1`, m.TableName(), EnCompanyPermissionColumns.EnCompanyPermissionId)
	err = global.DbMap[utils.DbNameReport].Raw(sql, id).First(&item).Error
	return
}

func (m *EnCompanyPermission) GetItemByCondition(condition string, pars []interface{}) (item *EnCompanyPermission, err error) {
	sql := fmt.Sprintf(`SELECT * FROM %s WHERE 1=1 `, m.TableName())
	sql += condition
	sql += ` LIMIT 1`
	err = global.DbMap[utils.DbNameReport].Raw(sql, pars...).First(&item).Error
	return
}

func (m *EnCompanyPermission) GetCountByCondition(condition string, pars []interface{}) (count int, err error) {
	sql := fmt.Sprintf(`SELECT COUNT(1) FROM %s WHERE 1=1 %s`, m.TableName(), condition)
	var countNull sql2.NullInt64
	err = global.DbMap[utils.DbNameReport].Raw(sql, pars...).Scan(&countNull).Error
	if err != nil {
		return
	}
	if countNull.Valid {
		count = int(countNull.Int64)
	}
	return
}

func (m *EnCompanyPermission) GetItemsByCondition(condition string, pars []interface{}, fieldArr []string, orderRule string) (items []*EnCompanyPermission, err error) {
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := `ORDER BY create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)
	err = global.DbMap[utils.DbNameReport].Raw(sql, pars...).Find(&items).Error
	return
}

func (m *EnCompanyPermission) GetPageItemsByCondition(startSize, pageSize int, condition string, pars []interface{}, fieldArr []string, orderRule string) (total int, items []*EnCompanyPermission, err error) {
	fields := strings.Join(fieldArr, ",")
	if len(fieldArr) == 0 {
		fields = `*`
	}
	order := `ORDER BY create_time DESC`
	if orderRule != "" {
		order = ` ORDER BY ` + orderRule
	}
	sql := fmt.Sprintf(`SELECT %s FROM %s WHERE 1=1 %s %s`, fields, m.TableName(), condition, order)

	totalSql := `SELECT COUNT(1) total FROM (` + sql + `) z`
	var totalNull sql2.NullInt64
	err = global.DbMap[utils.DbNameReport].Raw(totalSql, pars).Scan(&totalNull).Error
	if err != nil {
		return
	}
	if totalNull.Valid {
		total = int(totalNull.Int64)
	}

	sql += ` LIMIT ?,?`
	pars = append(pars, startSize)
	pars = append(pars, pageSize)
	err = global.DbMap[utils.DbNameReport].Raw(sql, pars...).Find(&items).Error
	return
}

func ClearAndCreateEnCompanyPermissions(companyId int, permissions []*EnCompanyPermission) (err error) {
	sql := `DELETE FROM en_company_permission WHERE en_company_id = ?`
	e := global.DbMap[utils.DbNameReport].Exec(sql, companyId).Error
	if e != nil {
		err = fmt.Errorf("delete err: %s", e.Error())
		return
	}
	if len(permissions) > 0 {
		e = global.DEFAULT_DB.CreateInBatches(permissions, utils.MultiAddNum).Error
		if e != nil {
			err = fmt.Errorf("insert multi err: %s", e.Error())
			return
		}
	}
	return
}

// GetEnglishCompanyIdsByEnPermissionIds 根据权限IDs获取报告IDs
func GetEnglishCompanyIdsByEnPermissionIds(permissionIds []int) (companyIds []int, err error) {
	if len(permissionIds) == 0 {
		return
	}
	sql := `SELECT DISTINCT a.en_company_id FROM en_company_permission AS a
			JOIN english_company AS b ON a.en_company_id = b.company_id
			WHERE a.en_permission_id IN (` + utils.GetOrmInReplace(len(permissionIds)) + `) AND b.status <> 3 AND b.enabled <> 0 AND b.is_deleted = 0`
	err = global.DbMap[utils.DbNameReport].Raw(sql, permissionIds).Find(&companyIds).Error
	return
}