package repositories

import (
    "errors"
    "fmt"
    "math"
    "strconv"
    "time"
    "xorm.io/xorm"
    "xps/cache"
    "xps/viewmodels"
)

type DataBusRepo struct {
    engine *xorm.Engine
}

func NewDataBusRepo(engine *xorm.Engine) *DataBusRepo {
    return &DataBusRepo{
        engine: engine,
    }
}

func (d *DataBusRepo) GetPage(sqlStatement, sqlCount string, m map[string]interface{}) (*viewmodels.PageResult, error) {
    limit := m["limit"].(int)
    page  := m["page"].(int)
    
    res, err1 := d.engine.Query(sqlCount)
    if err1 != nil {
        return nil, err1
    }
    
    total := int64(0)
    for _, v := range res[0] {
        total, _ = strconv.ParseInt(string(v), 10, 64)
    }
    
    pageStart  := (page - 1) * limit
    sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
    
    results, err2 := d.engine.QueryInterface(sqlStatement+ sqlLimit)
    if err2 != nil {
        return nil, err2
    }
    
    pageResult := &viewmodels.PageResult{}
    pageResult.Data     = results
    pageResult.Total    = total
    pageResult.PageSize = limit
    pageResult.Page     = page
    pageResult.TotalPage= int64(math.Ceil(float64(total / int64(limit))))
    return pageResult, nil
}

func (d *DataBusRepo) GetList(sqlStatement string, m map[string]interface{}) ([]map[string]interface{}, error) {
    results, err := d.engine.QueryInterface(sqlStatement)
    if err != nil {
        return nil, err
    }
    return results, nil
}

func (d *DataBusRepo) GetById(sqlStatement string, fields map[string]interface{})(map[string]interface{}, error){
    sql := sqlStatement
    sql += " WHERE 1 = 1"
    
    for fieldName, fieldValue := range fields {
        sql += fmt.Sprintf(" AND %v = %v", fieldName, fieldValue)
    }
    results, err   := d.engine.QueryInterface(sql)
    
    if err != nil {
        return nil, err
    }
    if len(results) > 1 {
        return nil, errors.New(" 主键不唯一")
    }
    
    return results[0], nil
}

func (d *DataBusRepo) Create(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObjectData(objectCode)
    if err1 == nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields    := object.Attrs
    
    sql := "INSERT INTO" + fmt.Sprintf(" %s ", tableName)
    sqlFields := "( "
    sqlValues := "( "
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
        
        if idx > 1 {
            sqlFields += ","
            sqlValues += ","
        }
    
        sqlFields += fieldName + ""
        sqlValues += fmt.Sprintf("%v", fieldValue) + ""
    }
    sqlFields += ") "
    sqlValues += ") "
    
    _, err2 := d.engine.Exec(sql + sqlFields + sqlValues)
    return err2
}

func (d *DataBusRepo) Update(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObjectData(objectCode)
    if err1 == nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields    := object.Attrs
    
    sql := fmt.Sprintf("UPDATE table %s ", tableName)
    
    sqlFieldSets := " SET "
    sqlWhere     := " WHERE 1 = 1 "
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
    
        if idx > 1 {
            sqlFieldSets += ","
        }
        
        if field.IsPKey <= 0 {
            sqlFieldSets += fmt.Sprintf(" %s = %v ", fieldName, fieldValue) + ""
        } else {
            sqlWhere += fmt.Sprintf(" AND %s = %v ", fieldName, fieldValue) + ""
        }
    }
    
    _, err := d.engine.Exec(sql + sqlFieldSets + sqlWhere)
    return err
}

func (d *DataBusRepo) Patch(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObjectData(objectCode)
    if err1 == nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields    := object.Attrs
    
    sql := fmt.Sprintf("UPDATE table %s ", tableName)
    
    sqlFieldSets := "SET "
    sqlWhere     := "WHERE 1 = 1"
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
        
        if idx > 1 {
            sqlFieldSets += ","
        }
        
        if field.IsPKey <= 0 {
            sqlFieldSets += fmt.Sprintf(" %s = %v ", fieldName, fieldValue) + ""
        } else {
            sqlWhere += fmt.Sprintf(" AND %s = %v ", fieldName, fieldValue) + ""
        }
    }
    
    _, err := d.engine.Exec(sql + sqlFieldSets + sqlWhere)
    return err
}


func (d *DataBusRepo) Delete(objectCode string, values map[string]interface{}) error {
    object, err1 := cache.GetModelObjectData(objectCode)
    if err1 == nil {
        return err1
    }
    
    tableName := object.ObjectCode
    fields    := object.Attrs
    
    deletedBy := values["deletedBy"].(int64)
    
    sql := fmt.Sprintf("UPDATE table %s ", tableName)
    sqlFieldSets   := fmt.Sprintf("SET deleted_flag = 1 AND deleted_by = %d AND deleted_at = %s", deletedBy, time.Now().String())
    
    sqlWhere := "WHERE 1 = 1"
    for idx, field := range fields {
        fieldName := field.AttrCode
        fieldValue, ok := values[fieldName]
        if !ok {
            return nil
        }
        
        if idx > 1 {
            sqlFieldSets += ","
        }
        
        if field.IsPKey >= 1 {
            sqlFieldSets += fmt.Sprintf(" %s = %v ", fieldName, fieldValue) + ""
        }
    }
    
    _, err := d.engine.Exec(sql + sqlFieldSets + sqlWhere)
    return err
}