package Function

import (
	"Cold_GoodsOrder/conf"
	"encoding/json"
	"fmt"
	"github.com/astaxie/beego/cache"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	_ "github.com/go-sql-driver/mysql"
	"strconv"
	"time"
)

// Address Order 模板
type Address struct {
	Id         int       `json:"Id" orm:"column(ID);size(11);auto;pk"`
	Name       string    `json:"T_name" orm:"size(256);null"`                          // 公司名称
	Address    string    `json:"T_Address" orm:"size(256);null"`                       // 地址详情
	Phone      string    `orm:"size(256);null"`                                        // 电话
	Email      string    `orm:"size(256);null"`                                        // 邮箱
	UserId     int       `orm:"index;size(256);null"`                                  // 用户ID
	CreateTime time.Time `orm:"column(create_time);type(timestamp);null;auto_now_add"` // 创建时间
	UpdateTime time.Time `orm:"column(update_time);type(timestamp);null;auto_now"`     // 更新时间
}
type AddressR struct {
	Id         int    `json:"Id"`        // ID
	Name       string `json:"T_name"`    // 地址名称
	Address    string `json:"T_Address"` // 地址详情
	Phone      string // 电话
	Email      string // 邮箱
	UserId     int    // 用户ID
	CreateTime string // 创建时间
	UpdateTime string // 更新时间
}

func AddressToAddressR(t Address) (r AddressR) {
	r.Id = t.Id
	r.Name = t.Name
	r.Address = t.Address
	r.Phone = t.Phone
	r.Email = t.Email
	r.UserId = t.UserId
	r.CreateTime = t.CreateTime.Format("2006-01-02 15:04:05")
	r.UpdateTime = t.UpdateTime.Format("2006-01-02 15:04:05")
	return
}

func (t *Address) TableName() string {
	return "address" // 数据库名称
}

var redisCache_Address cache.Cache

func init() {
	//注册模型
	orm.RegisterModel(new(Address))
	config := fmt.Sprintf(`{"key":"%s","conn":"%s","dbNum":"%s","password":"%s"}`,
		"redis_Address", conf.Redis_address, conf.Redis_dbNum, conf.Redis_password)
	fmt.Println(config)
	var err error
	redisCache_Address, err = cache.NewCache("redis", config)
	if err != nil || redisCache_Address == nil {
		errMsg := "failed to init redis"
		fmt.Println(errMsg, err)
	}

}

// ---------------- Redis -------------------
func Redis_Address_Set(r Address) (err error) {
	//json序列化
	str, err := json.Marshal(r)
	if err != nil {
		fmt.Print(err)
		return
	}

	err = redisCache_Address.Put(strconv.Itoa(r.Id), str, 24*time.Hour)
	if err != nil {
		fmt.Println("set key:", strconv.Itoa(r.Id), ",value:", str, err)
	}
	return
}

func Redis_Address_Get(key string) (r Address, is bool) {
	if redisCache_Address.IsExist(key) {
		//println("找到key:",key)
		v := redisCache_Address.Get(key)

		json.Unmarshal(v.([]byte), &r)
		return r, true
	}
	//println("没有 找到key:",key)
	return Address{}, false
}

func Redis_Address_DelK(key string) (err error) {
	err = redisCache_Address.Delete(key)
	return
}

// ---------------- 特殊方法 -------------------

// 获取 ById
func Read_Address_ById(id int) (r Address) {
	if r, is := Redis_Address_Get(strconv.Itoa(id)); is {
		return r
	}

	o := orm.NewOrm()
	r = Address{Id: id}
	err := o.Read(&r)
	if err != nil {
		fmt.Println(err)
	}
	return r
}

// 添加
func Add_Address(m Address) (id int64, err error) {
	o := orm.NewOrm()

	id, err = o.Insert(&m)
	if err != nil {
		fmt.Println(err)
	}
	Redis_Address_Set(m)
	return id, err
}

// 修改
func Update_Address(r Address, cols ...string) bool {
	o := orm.NewOrm()
	if num, err := o.Update(&r, cols...); err == nil {
		fmt.Println("Number of records updated in database:", num)
		Redis_Address_Set(r)
		return true
	}
	return false
}

// 删除
func Delete_Address(m Address) bool {
	o := orm.NewOrm()
	if num, err := o.Delete(&m); err == nil {
		fmt.Println("Number of records deleted in database:", num)
		Redis_Address_DelK(strconv.Itoa(m.Id))
		return true
	}
	return false
}

// 获取列表
func Read_Address_List(userId int, page int, page_z int, address, name string) (t []AddressR, cnt int64) {
	o := orm.NewOrm()

	// 也可以直接使用 Model 结构体作为表名
	qs := o.QueryTable(new(Address))
	var offset int64
	if page_z == 0 {
		page_z = conf.Page_size
	}
	var r []Address
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}

	cond := orm.NewCondition()
	cond1 := cond.And("UserId", userId)
	if len(address) > 0 {
		cond1 = cond1.And("address__icontains", address)
	}
	if len(name) > 0 {
		cond1 = cond1.And("name__icontains", name)
	}
	qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond1)).OrderBy("-Id").All(&r)
	cnt, _ = qs.SetCond((*orm2.Condition)(cond1)).Count()

	for _, v := range r {
		t = append(t, AddressToAddressR(v))
	}
	return t, cnt
}