package pendant

import (
	"bytes"
	"context"
	"database/sql"
	"fmt"
	"time"

	"go-common/app/service/main/usersuit/model"
	xsql "go-common/library/database/sql"
	"go-common/library/log"
	"go-common/library/xstr"

	"github.com/pkg/errors"
)

const (
	_getGroupOnlineSQL        = "SELECT id,name,rank,status,image,image_model,frequency_limit,time_limit FROM pendant_group WHERE status = 1 or id in (30,31) ORDER BY rank"
	_getGroupByIDSQL          = "SELECT id,name,rank,status,image,image_model,frequency_limit,time_limit FROM pendant_group where id = ?"
	_selGIDRefPIDSQL          = "SELECT gid,pid FROM pendant_group_ref"
	_getPendantInfoSQL        = "SELECT id,name,image,image_model,status FROM pendant_info"
	_getPendantInfoByIDSQL    = "SELECT id,name,image,image_model,status FROM pendant_info where id = ? limit 1"
	_getPendantInfosSQL       = "SELECT id,name,image,image_model,status,rank FROM pendant_info ORDER BY rank"
	_getPendantPriceSQL       = "SELECT pid,type,price FROM pendant_price where pid = ? "
	_getOrderHistorySQL       = "SELECT mid,order_id,pay_id,appid,status,pid,time_length,cost,buy_time,is_callback,callback_time,pay_type FROM user_pendant_order WHERE %s"
	_getUserPackageSQL        = "SELECT mid,pid,expires,type,status,is_vip FROM user_pendant_pkg WHERE mid = ? AND pid = ? "
	_getUserPackageByMidSQL   = "SELECT mid,pid,expires,type,status,is_vip FROM user_pendant_pkg WHERE mid = ? AND expires >= ? AND status > 0 ORDER BY mtime DESC"
	_countOrderHistorySQL     = "SELECT count(1) FROM user_pendant_order WHERE %s"
	_getPendantEquipByMidSQL  = "SELECT mid,pid,expires FROM user_pendant_equip WHERE mid = ? and expires >= ?"
	_getPendantEquipByMidsSQL = "SELECT mid,pid,expires FROM user_pendant_equip WHERE mid IN (%s) and expires >= ?"
	_insertPendantPackageSQL  = "INSERT INTO user_pendant_pkg(mid,pid,expires,type,status,is_vip) VALUES (?,?,?,?,?,?)"
	_insertOrderHistory       = "INSERT INTO user_pendant_order(mid,order_id,pay_id,appid,status,pid,time_length,cost,buy_time,is_callback,callback_time,pay_type) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)"
	_insertOperationSQL       = "INSERT INTO pendant_grant_history(mid,pid,source_type,operator_name,operator_action) VALUES (?,?,?,?,?)"
	_insertEquipSQL           = "INSERT INTO user_pendant_equip(mid,pid,expires) VALUES (?,?,?) ON DUPLICATE KEY UPDATE pid=VALUES(pid),expires=VALUES(expires)"
	_updatePackageSQL         = "UPDATE user_pendant_pkg %s WHERE mid=? AND pid=?"
	_updatePackageExpireSQL   = "UPDATE user_pendant_pkg SET status=0 WHERE mid=? AND expires<?"
	_updateOrderInfoSQL       = "UPDATE user_pendant_order SET status=?,pay_id=?,is_callback=?,callback_time=? WHERE order_id=?"
	_updateEquipMIDSQL        = "UPDATE user_pendant_equip SET pid=0,expires=0 WHERE mid=?"
)

//PendantGroupInfo return all group info
func (d *Dao) PendantGroupInfo(c context.Context) (res []*model.PendantGroupInfo, err error) {
	var row *xsql.Rows
	res = make([]*model.PendantGroupInfo, 0)

	if row, err = d.db.Query(c, _getGroupOnlineSQL); err != nil {
		log.Error("PendantGroupInfo query error %v", err)
		return
	}
	defer row.Close()
	for row.Next() {
		info := new(model.PendantGroupInfo)
		if err = row.Scan(&info.ID, &info.Name, &info.Rank, &info.Status, &info.Image, &info.ImageModel, &info.FrequencyLimit, &info.TimeLimit); err != nil {
			log.Error("PendantGroupInfo scan error %v", err)
			return
		}
		res = append(res, info)
	}
	return
}

// GroupByID return group info by id
func (d *Dao) GroupByID(c context.Context, gid int64) (res *model.PendantGroupInfo, err error) {
	var row *xsql.Row
	res = new(model.PendantGroupInfo)
	row = d.db.QueryRow(c, _getGroupByIDSQL, gid)

	if err = row.Scan(&res.ID, &res.Name, &res.Rank, &res.Status, &res.Image, &res.ImageModel, &res.FrequencyLimit, &res.TimeLimit); err != nil {
		if err == xsql.ErrNoRows {
			res = nil
			err = nil
			return
		}
		log.Error("PendantGroupInfo scan error %v", err)
		return
	}
	return
}

// GIDRefPID gid relation of pid .
func (d *Dao) GIDRefPID(c context.Context) (gidMap map[int64][]int64, pidMap map[int64]int64, err error) {
	var rows *xsql.Rows
	if rows, err = d.db.Query(c, _selGIDRefPIDSQL); err != nil {
		err = errors.WithStack(err)
		return
	}
	defer rows.Close()
	gidMap = make(map[int64][]int64)
	pidMap = make(map[int64]int64)
	for rows.Next() {
		var gid, pid int64
		if err = rows.Scan(&gid, &pid); err != nil {
			if err == xsql.ErrNoRows {
				gidMap = nil
				pidMap = nil
				err = nil
				return
			}
			err = errors.WithStack(err)
			return
		}
		pidMap[pid] = gid
		gidMap[gid] = append(gidMap[gid], pid)
	}
	return
}

// PendantList return pendant info
func (d *Dao) PendantList(c context.Context) (res []*model.Pendant, err error) {
	var (
		row *xsql.Rows
	)
	res = make([]*model.Pendant, 0)

	if row, err = d.db.Query(c, _getPendantInfosSQL); err != nil {
		log.Error("PendantInfo query error %v", err)
		return
	}
	defer row.Close()

	for row.Next() {
		info := new(model.Pendant)
		if err = row.Scan(&info.ID, &info.Name, &info.Image, &info.ImageModel, &info.Status, &info.Rank); err != nil {
			log.Error("PendantInfo scan error %v", err)
			return
		}
		res = append(res, info)
	}
	return
}

// Pendants return pendant info by ids
func (d *Dao) Pendants(c context.Context, pids []int64) (res []*model.Pendant, err error) {
	var (
		row *xsql.Rows
		bf  bytes.Buffer
	)
	res = make([]*model.Pendant, 0)
	bf.WriteString(_getPendantInfoSQL)
	bf.WriteString(" where id in(")
	bf.WriteString(xstr.JoinInts(pids))
	bf.WriteString(") and status = 1 ORDER BY rank")

	if row, err = d.db.Query(c, bf.String()); err != nil {
		log.Error("Pendants query error %v", err)
		return
	}

	defer row.Close()

	for row.Next() {
		info := new(model.Pendant)
		if err = row.Scan(&info.ID, &info.Name, &info.Image, &info.ImageModel, &info.Status); err != nil {
			log.Error("Pendants scan error %v", err)
			return
		}
		res = append(res, info)
	}

	return
}

// PendantInfo return pendant info by id
func (d *Dao) PendantInfo(c context.Context, pid int64) (res *model.Pendant, err error) {
	var (
		row *xsql.Row
	)
	res = new(model.Pendant)

	row = d.db.QueryRow(c, _getPendantInfoByIDSQL, pid)
	if err = row.Scan(&res.ID, &res.Name, &res.Image, &res.ImageModel, &res.Status); err != nil {
		if err == xsql.ErrNoRows {
			res = nil
			err = nil
			return
		}
		log.Error("Pendant scan error %v", err)
		return
	}
	return
}

// PendantPrice return pendant price
func (d *Dao) PendantPrice(c context.Context, pid int64) (res map[int64]*model.PendantPrice, err error) {
	var row *xsql.Rows
	res = make(map[int64]*model.PendantPrice)

	if row, err = d.db.Query(c, _getPendantPriceSQL, pid); err != nil {
		log.Error("PendantPrice query error %v", err)
		return
	}
	defer row.Close()

	for row.Next() {
		info := new(model.PendantPrice)
		if err = row.Scan(&info.Pid, &info.Type, &info.Price); err != nil {
			log.Error("PendantPrice scan error %v", err)
			return
		}
		res[info.Type] = info
	}
	return
}

// getOrderInfoSQL return a sql string
func (d *Dao) getOrderInfoSQL(c context.Context, arg *model.ArgOrderHistory, tp string) (sql string, values []interface{}) {
	values = make([]interface{}, 0, 5)
	var cond bytes.Buffer
	cond.WriteString("mid = ?")
	values = append(values, arg.Mid)

	if arg.OrderID != "" {
		cond.WriteString(" AND order_id = ?")
		values = append(values, arg.OrderID)
	}
	if arg.Pid != 0 {
		cond.WriteString(" AND pid = ?")
		values = append(values, arg.Pid)
	}
	if arg.Status != 0 {
		cond.WriteString(" AND status = ?")
		values = append(values, arg.Status)
	}
	if arg.PayType != 0 {
		cond.WriteString(" AND pay_type = ?")
		values = append(values, arg.PayType)
	}
	if arg.PayID != "" {
		cond.WriteString(" AND pay_id = ?")
		values = append(values, arg.PayID)
	}

	if arg.StartTime != 0 {
		cond.WriteString(" AND buy_time >= ?")
		values = append(values, arg.StartTime)
	}
	if arg.EndTime != 0 {
		cond.WriteString(" AND buy_time <= ?")
		values = append(values, arg.EndTime)
	}
	if tp == "info" {
		cond.WriteString(" order by buy_time DESC LIMIT ?,20")
		values = append(values, (arg.Page-1)*20)
		sql = fmt.Sprintf(_getOrderHistorySQL, cond.String())
	} else if tp == "count" {
		sql = fmt.Sprintf(_countOrderHistorySQL, cond.String())
	}
	return
}

// OrderInfo return order info
func (d *Dao) OrderInfo(c context.Context, arg *model.ArgOrderHistory) (res []*model.PendantOrderInfo, count int64, err error) {
	sqlstr, values := d.getOrderInfoSQL(c, arg, "info")
	var (
		row *xsql.Rows
		r   *xsql.Row
	)

	res = make([]*model.PendantOrderInfo, 0)

	if row, err = d.db.Query(c, sqlstr, values...); err != nil {
		log.Error("PendantOrderInfo query error %v", err)
		return
	}
	defer row.Close()
	cstr, values2 := d.getOrderInfoSQL(c, arg, "count")
	r = d.db.QueryRow(c, cstr, values2...)

	for row.Next() {
		info := new(model.PendantOrderInfo)
		if err = row.Scan(&info.Mid, &info.OrderID, &info.PayID, &info.AppID, &info.Stauts, &info.Pid, &info.TimeLength, &info.Cost, &info.BuyTime, &info.IsCallback, &info.CallbackTime, &info.PayType); err != nil {
			log.Error("PendantOrderInfo scan error %v", err)
			return
		}
		if info.PayType == 3 {
			info.PayPrice = info.PayPrice / 100
		}
		res = append(res, info)
	}
	err = r.Scan(&count)
	if err == xsql.ErrNoRows {
		res = nil
		err = nil
		return
	}
	return
}

// OrderInfoByID return order info by order id
func (d *Dao) OrderInfoByID(c context.Context, orderID string) (res *model.PendantOrderInfo, err error) {
	row := d.db.QueryRow(c, fmt.Sprintf(_getOrderHistorySQL, "order_id=?"), orderID)
	res = new(model.PendantOrderInfo)
	if err = row.Scan(&res.Mid, &res.OrderID, &res.PayID, &res.AppID, &res.Stauts, &res.Pid, &res.TimeLength, &res.Cost, &res.BuyTime, &res.IsCallback, &res.CallbackTime, &res.PayType); err != nil {
		if err == xsql.ErrNoRows {
			res = nil
			err = nil
			return
		}
		log.Error("OrderInfoByID scan error %v", err)
		return
	}
	return
}

// AddOrderInfo add order log
func (d *Dao) AddOrderInfo(c context.Context, arg *model.PendantOrderInfo) (id int64, err error) {
	var res sql.Result
	if res, err = d.db.Exec(c, _insertOrderHistory, arg.Mid, arg.OrderID, arg.PayID, arg.AppID, arg.Stauts, arg.Pid, arg.TimeLength, arg.Cost, arg.BuyTime, arg.IsCallback, arg.CallbackTime, arg.PayType); err != nil {
		log.Error("AddOrderInfo insert error %v", err)
		return
	}
	return res.LastInsertId()
}

// TxAddOrderInfo add order log
func (d *Dao) TxAddOrderInfo(c context.Context, arg *model.PendantOrderInfo, tx *xsql.Tx) (id int64, err error) {
	var res sql.Result
	if res, err = tx.Exec(_insertOrderHistory, arg.Mid, arg.OrderID, arg.PayID, arg.AppID, arg.Stauts, arg.Pid, arg.TimeLength, arg.Cost, arg.BuyTime, arg.IsCallback, arg.CallbackTime, arg.PayType); err != nil {
		log.Error("TxAddOrderInfo insert error %v", err)
		return
	}
	return res.LastInsertId()
}

// UpdateOrderInfo update order info
func (d *Dao) UpdateOrderInfo(c context.Context, arg *model.PendantOrderInfo) (id int64, err error) {
	var res sql.Result
	if res, err = d.db.Exec(c, _updateOrderInfoSQL, arg.Stauts, arg.PayID, arg.IsCallback, arg.CallbackTime, arg.OrderID); err != nil {
		log.Error("UpdateOrderInfo update error %v", err)
		return
	}
	return res.LastInsertId()
}

// TxUpdateOrderInfo update order info
func (d *Dao) TxUpdateOrderInfo(c context.Context, arg *model.PendantOrderInfo, tx *xsql.Tx) (id int64, err error) {
	var res sql.Result
	if res, err = tx.Exec(_updateOrderInfoSQL, arg.Stauts, arg.PayID, arg.IsCallback, arg.CallbackTime, arg.OrderID); err != nil {
		log.Error("UpdateOrderInfo update error %v", err)
		return
	}
	return res.LastInsertId()
}

// PackageByMid get pendant in user's package
func (d *Dao) PackageByMid(c context.Context, mid int64) (res []*model.PendantPackage, err error) {
	var (
		row *xsql.Rows
		t   = time.Now().Unix()
	)
	res = make([]*model.PendantPackage, 0)

	if row, err = d.db.Query(c, _getUserPackageByMidSQL, mid, t); err != nil {
		log.Error("Package query error %v", err)
		return
	}
	defer row.Close()
	for row.Next() {
		info := new(model.PendantPackage)
		if err = row.Scan(&info.Mid, &info.Pid, &info.Expires, &info.Type, &info.Status, &info.IsVIP); err != nil {
			log.Error("Package scan error %v", err)
			return
		}
		res = append(res, info)
	}
	return
}

// PackageByID get pendant in user's package
func (d *Dao) PackageByID(c context.Context, mid, pid int64) (res *model.PendantPackage, err error) {
	var row *xsql.Row
	res = new(model.PendantPackage)
	row = d.db.QueryRow(c, _getUserPackageSQL, mid, pid)
	if err = row.Scan(&res.Mid, &res.Pid, &res.Expires, &res.Type, &res.Status, &res.IsVIP); err != nil {
		if err == xsql.ErrNoRows {
			res = nil
			err = nil
			return
		}
		log.Error("Package scan error %v", err)
		return
	}
	return
}

// EquipByMid obtain pendant equiped
func (d *Dao) EquipByMid(c context.Context, mid, t int64) (res *model.PendantEquip, noRow bool, err error) {
	var row *xsql.Row
	res = new(model.PendantEquip)
	row = d.db.QueryRow(c, _getPendantEquipByMidSQL, mid, t)
	if err = row.Scan(&res.Mid, &res.Pid, &res.Expires); err != nil {
		if err == xsql.ErrNoRows {
			noRow = true
			res = nil
			err = nil
			return
		}
		err = errors.WithStack(err)
	}
	return
}

// EquipByMids obtain equipss by mids .
func (d *Dao) EquipByMids(c context.Context, mids []int64, t int64) (res map[int64]*model.PendantEquip, err error) {
	res = make(map[int64]*model.PendantEquip)
	rows, err := d.db.Query(c, fmt.Sprintf(_getPendantEquipByMidsSQL, xstr.JoinInts(mids)), t)
	if err != nil {
		err = errors.WithStack(err)
		return
	}
	defer rows.Close()
	for rows.Next() {
		pe := &model.PendantEquip{}
		if err = rows.Scan(&pe.Mid, &pe.Pid, &pe.Expires); err != nil {
			if err == xsql.ErrNoRows {
				err = nil
				return
			}
			err = errors.WithStack(err)
		}
		if _, ok := res[pe.Mid]; !ok {
			res[pe.Mid] = pe
		}
	}
	err = rows.Err()
	return
}

// AddEquip add equip
func (d *Dao) AddEquip(c context.Context, arg *model.PendantEquip) (n int64, err error) {
	var res sql.Result
	if res, err = d.db.Exec(c, _insertEquipSQL, arg.Mid, arg.Pid, arg.Expires); err != nil {
		return 0, err
	}
	return res.RowsAffected()
}

// UpEquipMID uninstall user pid by mid.
func (d *Dao) UpEquipMID(c context.Context, mid int64) (n int64, err error) {
	var res sql.Result
	if res, err = d.db.Exec(c, _updateEquipMIDSQL, mid); err != nil {
		return 0, err
	}
	return res.RowsAffected()
}

// TxUpdatePackageInfo update package info
func (d *Dao) TxUpdatePackageInfo(c context.Context, arg *model.PendantPackage, tx *xsql.Tx) (n int64, err error) {
	var (
		bf     bytes.Buffer
		values = make([]interface{}, 0, 4)
		res    sql.Result
	)
	if arg.Status != 0 && arg.Expires != 0 {
		bf.WriteString("SET status=?,expires=?,type=?")
		values = append(values, arg.Status)
		values = append(values, arg.Expires)
		values = append(values, arg.Type)
	} else if arg.Status != 0 {
		bf.WriteString("SET status=?,type=?")
		values = append(values, arg.Status)
		values = append(values, arg.Type)
	} else if arg.Expires != 0 {
		bf.WriteString("SET expires=?,type=?")
		values = append(values, arg.Expires)
		values = append(values, arg.Type)
	}
	values = append(values, arg.Mid)
	values = append(values, arg.Pid)
	if res, err = tx.Exec(fmt.Sprintf(_updatePackageSQL, bf.String()), values...); err != nil {
		log.Error("TxUpdatePackageInfo update error %v", err)
		return
	}
	return res.RowsAffected()
}

// CheckPackageExpire check expire items and update
func (d *Dao) CheckPackageExpire(c context.Context, mid, expires int64) (rows int64, err error) {
	var res sql.Result
	if res, err = d.db.Exec(c, _updatePackageExpireSQL, mid, expires); err != nil {
		log.Error("CheckPackageExpire error %v", err)
		return
	}
	return res.RowsAffected()
}

// BeginTran begin a tx.
func (d *Dao) BeginTran(c context.Context) (res *xsql.Tx, err error) {
	if res, err = d.db.Begin(c); err != nil || res == nil {
		log.Error("BeginTran  error %v", err)
		return
	}
	return
}

// TxAddPackage add a pendant in package
func (d *Dao) TxAddPackage(c context.Context, arg *model.PendantPackage, tx *xsql.Tx) (id int64, err error) {
	var res sql.Result
	if res, err = tx.Exec(_insertPendantPackageSQL, arg.Mid, arg.Pid, arg.Expires, arg.Type, arg.Status, arg.IsVIP); err != nil {
		log.Error("TxAddPackage insert error %v", err)
		return
	}
	return res.LastInsertId()
}

// TxAddHistory add a history of operation
func (d *Dao) TxAddHistory(c context.Context, arg *model.PendantHistory, tx *xsql.Tx) (id int64, err error) {
	var res sql.Result
	if res, err = tx.Exec(_insertOperationSQL, arg.Mid, arg.Pid, arg.SourceType, arg.OperatorName, arg.OperatorAction); err != nil {
		log.Error("TxAddHistory insert error %v", err)
		return
	}
	return res.LastInsertId()
}