package repository

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

type ApiLogRepo struct {
	engine *xorm.Engine
}

func NewApiLogRepo(engine *xorm.Engine) *ApiLogRepo {
	return &ApiLogRepo{
		engine: engine,
	}
}

func (d *ApiLogRepo) GetPage(m map[string]interface{}) (*base.PageResult, error) {
	limit := m["limit"].(int)
	page := m["page"].(int)

	sqlSelect := ` SELECT       A.*,
                                B.app_title,
                                C.api_title                             `
	sqlFrom := ` FROM         api_log   AS A
                   LEFT  JOIN   app       AS B ON (A.app_id = B.app_id)
                   LEFT  JOIN   api       AS C ON (A.api_id = C.api_id)`
	sqlWhere := ` WHERE 1 = 1  `
	if apiId, ok := m["apiId"]; ok {
		sqlWhere += ` AND A.api_id = ` + fmt.Sprintf("%d", apiId)
	}
	if accountId, ok := m["accountId"]; ok {
		sqlWhere += ` AND A.account_id = ` + fmt.Sprintf("%d", accountId)
	}
	if keywords, ok := m["keywords"]; ok {
		sqlWhere += ` AND A.api_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
	}

	sqlCount := ` SELECT COUNT(*) `
	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodel.ApiLog))
	if err1 != nil {
		return nil, err1
	}
	sqlOrderBy := " ORDER BY A.req_id ASC "

	pageStart := (page - 1) * limit
	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)

	datalist := make([]datamodel.ApiLog, 0)
	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
	if err2 != nil {
		return nil, err2
	}

	pageResult := &base.PageResult{}
	pageResult.Data = datalist
	pageResult.Total = total
	pageResult.PageSize = limit
	pageResult.Page = page
	return pageResult, nil
}

func (d *ApiLogRepo) GetList(m map[string]interface{}) ([]viewmodel.ApiLogInfo, error) {
	sqlSelect := ` SELECT       A.*,
                                B.app_title,
                                C.api_title      `
	sqlFrom := ` FROM         api_log   AS A
                   LEFT  JOIN   app       AS B ON (A.app_id = B.app_id)
                   LEFT  JOIN   api       AS C ON (A.api_id = C.api_id)`
	sqlWhere := ` WHERE 1 = 1  `

	if apiId, ok := m["apiId"]; ok {
		sqlWhere += ` AND A.api_id = ` + fmt.Sprintf("%d", apiId)
	}

	if accountId, ok := m["accountId"]; ok {
		sqlWhere += ` AND A.account_id = ` + fmt.Sprintf("%d", accountId)
	}

	if keywords, ok := m["keywords"]; ok {
		sqlWhere += ` AND A.api_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
	}
	sqlOrderBy := " ORDER BY A.req_id ASC "

	datalist := make([]viewmodel.ApiLogInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *ApiLogRepo) GetById(reqId int64) (*viewmodel.ApiLogInfo, error) {
	data := &viewmodel.ApiLogInfo{}
	ok, err := d.engine.
		Where("req_id = ?", reqId).
		Get(data)
	if !ok && err == nil {
		return nil, err
	} else {
		return data, nil
	}
}

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