package budget

import (
	"time"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"

	"github.com/gin-gonic/gin"
)

type QuoteData interface {
	GetID() int64
	GetProp(string) (string, bool)
	GetSubs() *[]QuoteData
	GetHeaders() *[]QuoteData
	GetName() string
	GetItem() *Item
	GetValue() string
	GetQuote() *Quote
	GetTable() *Table
	GetHeader() *Header
	GetModule() *Module
	GetGroup() *Group
	GetRow() *Row
	GetMyItem() *Item
}

type Quote struct {
	ID        int64             `json:"id" prop:"add:false"`
	Name      string            `json:"name" label:"报价名称" type:"string" prop:"add edit" search:"like"`
	State     int64             `json:"state" label:"状态" type:"int" prop:"edit" default:"0" search:"="`
	Property  string            `json:"property" label:"属性" type:"string" prop:"edit"`
	DeletedAt int64             `json:"deleted_at" prop:"add:false select:false"`
	CreatedAt int64             `json:"created_at" prop:"add:false select:false"`
	UpdatedAt int64             `json:"updated_at" prop:"add:false select:false"`
	Tables    []QuoteData       `json:"tables" prop:"ignore"`
	Prop      map[string]string `json:"prop" prop:"ignore"`
	db.BaseModel
}

func (Quote) TableName() string {
	return "zy_budget_quote"
}

func (Quote) ListPrivilege(c *gin.Context, data map[string]interface{}, s *db.Select) bool {
	return true
}

func (Quote) OnePrivilege(c *gin.Context, id int64) bool {
	return true
}

func (Quote) AddPrivilege(c *gin.Context, data map[string]interface{}, post map[string]interface{}) error {
	return nil
}

func (Quote) EditPrivilege(c *gin.Context, id int64, data map[string]interface{}, post map[string]interface{}) error {
	return nil
}

func (Quote) DelPrivilege(c *gin.Context, id int64) error {
	return nil
}

func (model Quote) AddAfter(c *gin.Context, id int64, post map[string]interface{}, data map[string]interface{}) {
	if use, ok := post["use"].(float64); ok && use != 0 {
		quote, _, _, _, _, _, _ := GetQuoteModel(int64(use))
		if quote != nil {
			db.UpdateModel(db.Type(model), id, map[string]interface{}{
				"property": quote.Property,
			})
			order := time.Now().Unix()
			CopyTables(quote.Tables, id, order)
		}
	}
}

func (Quote) Page() bool {
	return true
}

func (Quote) Count() bool {
	return true
}

func (model Quote) GetProperty() map[string]string {
	props := make(map[string]string)
	utils.JsonDecode(model.Property).To(&props)
	return props
}

func (model Quote) GetID() int64 {
	return model.ID
}

func (model Quote) GetProp(name string) (expression string, ok bool) {
	expression, ok = model.Prop[name]
	return
}

func (model Quote) GetSubs() *[]QuoteData {
	return &model.Tables
}

func (model Quote) GetName() string {
	return model.Name
}

func (model Quote) GetHeaders() *[]QuoteData {
	return nil
}

func (model Quote) GetItem() *Item {
	return nil
}

func (model Quote) GetValue() string {
	return ""
}

func (model Quote) GetQuote() *Quote {
	return &model
}

func (model Quote) GetTable() *Table {
	return nil
}

func (model Quote) GetHeader() *Header {
	return nil
}

func (model Quote) GetModule() *Module {
	return nil
}

func (model Quote) GetGroup() *Group {
	return nil
}

func (model Quote) GetRow() *Row {
	return nil
}

func (model Quote) GetMyItem() *Item {
	return nil
}

func GetQuoteModel(id int64) (quote *Quote, tables []QuoteData, headers []QuoteData, modules []QuoteData, groups []QuoteData, rows []QuoteData, items []QuoteData) {
	db.GetModel(map[string]interface{}{"id": id}, &quote)
	if quote != nil {

		var tablelist []Table
		var headerlist []Header
		var modulelist []Module
		var grouplist []Group
		var rowlist []Row
		var itemlist []Item

		where := map[string]interface{}{
			"quoteId":    id,
			"deleted_at": 0,
		}

		db.GetModel(where, &tablelist)
		db.GetModel(where, &headerlist)
		db.GetModel(where, &modulelist)
		db.GetModel(where, &grouplist)
		db.GetModel(where, &rowlist)

		itemids := make([]int64, 0)
		for _, row := range rowlist {
			if row.ItemId != 0 {
				itemids = append(itemids, row.ItemId)
			}
		}

		if len(itemids) != 0 {
			itemlist, items = GetItemModels(map[string]interface{}{
				"id in":      itemids,
				"deleted_at": 0,
			})
		}

		for _, header := range headerlist {
			headers = append(headers, header)
		}

		quote.Prop = quote.GetProperty()
		tables, modules, groups, rows = findTables(quote.ID, tablelist, headerlist, modulelist, grouplist, rowlist, itemlist)
		quote.Tables = tables
	}
	return
}

func (model Quote) Copy(name string) (int64, error) {
	order := time.Now().Unix()
	id, err := db.InsertModel(db.Type(model), map[string]interface{}{
		"name":     name,
		"property": model.Property,
		"order_at": order,
	})
	if err != nil {
		return 0, err
	}
	err = CopyTables(model.Tables, id, order)
	if err != nil {
		return id, err
	}
	return id, nil
}