package routers

import (
	"context"
	"encoding/json"
	parsefmt "fmt"
	"ops/agents"
	"ops/models"
	"slices"
	"strings"
	"time"

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

var (
	purchaseUserGroup TabUserGroups
	purchaseAdmins    []uint
)

// 更新管理员成员缓存
func PurchaseUpdateAdminsCash() {
	purchaseAdmins = nil
	// id 1 是系统管理员
	purchaseAdmins = append(purchaseAdmins, 1)
	var binds []TabUserGroupBinds
	models.DB.Where("group_id = ?", purchaseUserGroup.ID).Find(&binds)
	for _, item := range binds {
		if !slices.Contains(purchaseAdmins, item.UserID) {
			purchaseAdmins = append(purchaseAdmins, item.UserID)
		}
	}
}

// 判断用户是否有权限修改/删除订单（创建者或管理员）
func canModifyPurchase(userID, creatorUserID uint) bool {
	if slices.Contains(purchaseAdmins, userID) {
		return true
	}
	if userID == creatorUserID {
		return true
	}
	return false
}

// decodeJSON 将 map 通过 JSON 中转解码到目标结构体，绕过 mapstructure 的字段名匹配问题
func decodeJSON(data map[string]interface{}, out interface{}) error {
	jsonBytes, err := json.Marshal(data)
	if err != nil {
		return err
	}
	return json.Unmarshal(jsonBytes, out)
}

type CostItem struct {
	Cost         int `json:"cost"`         // 费用（分）
	CostT        int `json:"costt"`        // 总价
	CurrencyType int `json:"currencytype"` // 货币类型: 1-CNY 2-MOP 3-HKD 4-USD
	Int          int `json:"int"`          // 数量
	Type         int `json:"type"`         // 费用类型: 1-单价 2-运费
}
type From_purchase_addorder struct {
	Costs       []CostItem `json:"costs"`        //  成本
	Link        string     `json:"link"`         //  链接
	OrderStatus string     `json:"order_status"` //  订单状态
	Photos      []string   `json:"photos"`       //  图片备注
	Remark      string     `json:"remark"`       //  备注
	Styles      string     `json:"styles"`       //  样式备注
	Title       string     `json:"title"`        //  标题
}

type TabPurchaseOrder struct {
	ID          uint           `gorm:"primarykey"`
	UserID      uint           `gorm:"not null"`
	Title       string         `gorm:"size:200;comment:标题"`
	Remark      string         `gorm:"type:text;comment:备注"`
	Link        string         `gorm:"size:1000;comment:链接"`
	Styles      string         `gorm:"type:text;comment:样式数组"`
	OrderStatus string         `gorm:"size:50;default:pending;comment:订单状态: pending-待处理 ordered-已下单 arrived-已到达 received-已收件 lost-丢件 returned-退件"`
	CreatedAt   *time.Time     `gorm:"type:datetime;autoCreateTime"`
	UpdatedAt   *time.Time     `gorm:"type:datetime;autoUpdateTime"`
	DeletedAt   gorm.DeletedAt `gorm:"index"`
}

type TabPurchaseCosts struct {
	ID           uint       `gorm:"primarykey"`
	OrderID      uint       `gorm:"not null"`
	UserID       uint       `gorm:"not null"`
	Price        int        `gorm:"not null"`
	Quantity     int        `gorm:"not null"`
	CurrencyType int        `gorm:"default:1;comment:货币类型: 1-CNY 2-MOP 3-HKD 4-USD"`
	CostType     int        `gorm:"default:1;comment:费用类型: 1-单价 2-运费"`
	CreatedAt    *time.Time `gorm:"type:datetime;autoCreateTime"`
}

// TabPurchaseCommit 记录订单状态变更及评论
type TabPurchaseCommit struct {
	ID        uint       `gorm:"primarykey"`
	OrderID   uint       `gorm:"not null;index;comment:关联订单ID"`
	UserID    uint       `gorm:"not null;comment:操作人ID"`
	Action    string     `gorm:"size:50;not null;comment:操作类型: create-创建 create_status-状态变更"`
	Status    string     `gorm:"size:50;comment:变更后的状态"`
	OldStatus string     `gorm:"size:50;comment:变更前的状态"`
	Comment   string     `gorm:"type:text;comment:评论/备注"`
	Photos    string     `gorm:"type:text;comment:变更图片(JSON数组，存放sha256哈希)"`
	IP        string     `gorm:"size:50;comment:操作IP"`
	CreatedAt *time.Time `gorm:"type:datetime;autoCreateTime"`
}

type TabPurchaseLog struct {
	ID         uint   `gorm:"primarykey"`
	OrderID    uint   `gorm:"not null;index;comment:关联OrderID"`
	UserID     uint   `gorm:"not null;comment:操作人ID"`
	ActionType string `gorm:"size:50;not null;comment:操作类型: create-创建 update-修改 delete-删除 query-查询"`
	OldContent string `gorm:"type:text;comment:修改前内容(JSON)"`
	NewContent string `gorm:"type:text;comment:修改后内容(JSON)"`
	IP         string `gorm:"size:50;comment:操作IP"`
	Remark     string `gorm:"size:500;comment:备注/操作描述"`

	CreatedAt *time.Time `gorm:"type:datetime;autoCreateTime;comment:操作时间"`
}

type purchaseProvider struct{}

func (purchaseProvider) QueryPurchases(ctx context.Context, query agents.PurchaseQuery) (*agents.PurchaseQueryResult, error) {
	select {
	case <-ctx.Done():
		return nil, ctx.Err()
	default:
	}

	result := &agents.PurchaseQueryResult{
		Ok:       true,
		Action:   query.Action,
		LoggedIn: query.UserID > 0,
	}
	if !result.LoggedIn {
		result.Message = "需要登录才能查询采购模块信息。"
		return result, nil
	}

	switch query.Action {
	case "count":
		counts, err := queryPurchaseCounts(query)
		if err != nil {
			return nil, err
		}
		result.Counts = counts
		return result, nil
	case "get":
		order, err := queryPurchaseOrderDetail(query.OrderID, query.UserID)
		if err != nil {
			return nil, err
		}
		result.Order = order
		if order != nil {
			result.Count = 1
		}
		return result, nil
	default:
		orders, total, err := queryPurchaseOrderList(query)
		if err != nil {
			return nil, err
		}
		result.Orders = orders
		result.Count = len(orders)
		result.Total = total
		result.Page = query.Page
		result.Limit = query.Limit
		result.Filters = map[string]interface{}{
			"search":     query.Search,
			"status":     query.Status,
			"start_date": query.StartDate,
			"end_date":   query.EndDate,
		}
		return result, nil
	}
}

func applyPurchaseQueryFilters(db *gorm.DB, query agents.PurchaseQuery) (*gorm.DB, error) {
	if query.Search != "" {
		var id uint
		if _, err := parsefmt.Sscanf(query.Search, "%d", &id); err == nil && id > 0 {
			db = db.Where("id = ?", id)
		} else {
			db = db.Where("title LIKE ? OR remark LIKE ?", "%"+query.Search+"%", "%"+query.Search+"%")
		}
	}
	if query.Status != "" {
		db = db.Where("order_status = ?", query.Status)
	}
	if query.StartDate != "" {
		startDate, err := time.Parse("2006-01-02", query.StartDate)
		if err != nil {
			return nil, err
		}
		db = db.Where("created_at >= ?", startDate)
	}
	if query.EndDate != "" {
		endDate, err := time.Parse("2006-01-02", query.EndDate)
		if err != nil {
			return nil, err
		}
		db = db.Where("created_at < ?", endDate.AddDate(0, 0, 1))
	}
	return db, nil
}

func queryPurchaseOrderList(query agents.PurchaseQuery) ([]agents.PurchaseOrder, int64, error) {
	db, err := applyPurchaseQueryFilters(models.DB.Model(&TabPurchaseOrder{}), query)
	if err != nil {
		return nil, 0, err
	}
	var total int64
	if err := db.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	var rows []TabPurchaseOrder
	if err := db.Order("updated_at DESC, id DESC").Offset(query.Limit * (query.Page - 1)).Limit(query.Limit).Find(&rows).Error; err != nil {
		return nil, 0, err
	}

	orders := make([]agents.PurchaseOrder, 0, len(rows))
	for _, row := range rows {
		order, err := queryPurchaseOrderDetail(row.ID, query.UserID)
		if err != nil {
			return nil, 0, err
		}
		if order != nil {
			orders = append(orders, *order)
		}
	}
	return orders, total, nil
}

func queryPurchaseOrderDetail(orderID uint, userID uint) (*agents.PurchaseOrder, error) {
	var row TabPurchaseOrder
	if err := models.DB.Where("id = ?", orderID).First(&row).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, nil
		}
		return nil, err
	}
	order := buildPurchaseOrder(row, userID)

	var costs []TabPurchaseCosts
	if err := models.DB.Where("order_id = ?", orderID).Order("id asc").Find(&costs).Error; err != nil {
		return nil, err
	}
	order.Costs = make([]agents.PurchaseCost, 0, len(costs))
	for _, cost := range costs {
		order.Costs = append(order.Costs, agents.PurchaseCost{
			ID:           cost.ID,
			OrderID:      cost.OrderID,
			UserID:       cost.UserID,
			Price:        cost.Price,
			Quantity:     cost.Quantity,
			CurrencyType: cost.CurrencyType,
			CurrencyName: purchaseCurrencyName(cost.CurrencyType),
			CostType:     cost.CostType,
			CostTypeName: purchaseCostTypeName(cost.CostType),
		})
	}

	var commits []TabPurchaseCommit
	if err := models.DB.Where("order_id = ?", orderID).Order("created_at DESC").Find(&commits).Error; err != nil {
		return nil, err
	}
	order.Commits = make([]agents.PurchaseCommit, 0, len(commits))
	for _, commit := range commits {
		order.Commits = append(order.Commits, agents.PurchaseCommit{
			ID:        commit.ID,
			OrderID:   commit.OrderID,
			UserID:    commit.UserID,
			Action:    commit.Action,
			Status:    commit.Status,
			OldStatus: commit.OldStatus,
			Comment:   commit.Comment,
			CreatedAt: formatTimePtr(commit.CreatedAt),
		})
	}
	return &order, nil
}

func queryPurchaseCounts(query agents.PurchaseQuery) (map[string]int64, error) {
	counts := map[string]int64{}
	statuses := []string{"pending", "ordered", "arrived", "received", "lost", "returned"}
	var total int64
	base, err := applyPurchaseQueryFilters(models.DB.Model(&TabPurchaseOrder{}), agents.PurchaseQuery{Search: query.Search, StartDate: query.StartDate, EndDate: query.EndDate})
	if err != nil {
		return nil, err
	}
	if err := base.Count(&total).Error; err != nil {
		return nil, err
	}
	counts["total"] = total
	for _, status := range statuses {
		statusQuery := agents.PurchaseQuery{Search: query.Search, Status: status, StartDate: query.StartDate, EndDate: query.EndDate}
		db, err := applyPurchaseQueryFilters(models.DB.Model(&TabPurchaseOrder{}), statusQuery)
		if err != nil {
			return nil, err
		}
		var count int64
		if err := db.Count(&count).Error; err != nil {
			return nil, err
		}
		counts[status] = count
	}
	return counts, nil
}

func buildPurchaseOrder(row TabPurchaseOrder, currentUserID uint) agents.PurchaseOrder {
	return agents.PurchaseOrder{
		ID:              row.ID,
		UserID:          row.UserID,
		Title:           row.Title,
		Remark:          row.Remark,
		Link:            row.Link,
		DetailURL:       purchaseOrderDetailURL(row.ID),
		Styles:          row.Styles,
		OrderStatus:     row.OrderStatus,
		OrderStatusName: purchaseStatusName(row.OrderStatus),
		CreatedAt:       formatTimePtr(row.CreatedAt),
		UpdatedAt:       formatTimePtr(row.UpdatedAt),
		CanModify:       canModifyPurchase(currentUserID, row.UserID),
	}
}

func purchaseOrderDetailURL(orderID uint) string {
	return parsefmt.Sprintf("/purchase/showorder/%d", orderID)
}

func formatTimePtr(t *time.Time) string {
	if t == nil {
		return ""
	}
	return t.Format("2006-01-02 15:04:05")
}

func purchaseStatusName(status string) string {
	switch status {
	case "pending":
		return "待处理"
	case "ordered":
		return "已下单"
	case "arrived":
		return "已到达"
	case "received":
		return "已收件"
	case "lost":
		return "丢件"
	case "returned":
		return "退件"
	default:
		return status
	}
}

func purchaseCurrencyName(currencyType int) string {
	switch currencyType {
	case 1:
		return "CNY"
	case 2:
		return "MOP"
	case 3:
		return "HKD"
	case 4:
		return "USD"
	default:
		return "未知"
	}
}

func purchaseCostTypeName(costType int) string {
	switch costType {
	case 1:
		return "单价"
	case 2:
		return "运费"
	default:
		return "未知"
	}
}

func ApiPurchaseInit() {

	models.DB.AutoMigrate(&TabPurchaseOrder{})
	models.DB.AutoMigrate(&TabPurchaseCosts{})

	models.DB.AutoMigrate(&TabPurchaseLog{})
	models.DB.AutoMigrate(&TabPurchaseCommit{})

	//先检查用户组有没有这个key  purchase
	purchaseUserGroup.Name = "purchase_admin"
	if models.DB.Where(&purchaseUserGroup).First(&purchaseUserGroup).Error == nil {
		PurchaseUpdateAdminsCash()
	} else {
		purchaseUserGroup.Type = "usergroup"
		models.DB.Create(&purchaseUserGroup)
	}

	agents.RegisterPurchaseProvider(purchaseProvider{})
}

func ApiPurchase(r *gin.RouterGroup) {

	r.POST("/getorder", func(ctx *gin.Context) {
		isAuth, user, data := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type FromGetOrder struct {
			ID uint `json:"id"`
		}
		var from FromGetOrder
		if err := decodeJSON(data, &from); err != nil || from.ID == 0 {
			ReturnJson(ctx, "jsonErr", nil)
			return
		}

		var order TabPurchaseOrder
		if err := models.DB.Where("id = ?", from.ID).First(&order).Error; err != nil {
			ReturnJson(ctx, "order_not_found", nil)
			return
		}

		// 查询关联费用
		var costs []TabPurchaseCosts
		models.DB.Where("order_id = ?", from.ID).Find(&costs)

		// 查询关联图片
		var binds []TabPurchaseFileBind
		models.DB.Where("order_id = ?", from.ID).Find(&binds)
		var fileIDs []uint
		for _, b := range binds {
			fileIDs = append(fileIDs, b.FileID)
		}
		var files []TabFileInfo
		if len(fileIDs) > 0 {
			models.DB.Where("id IN ?", fileIDs).Find(&files)
		}

		// 查询状态变更记录
		var commits []TabPurchaseCommit
		models.DB.Where("order_id = ?", from.ID).Order("created_at DESC").Find(&commits)

		// 解析每条 commit 的 Photos JSON 字段为数组
		type CommitResponse struct {
			ID        uint      `json:"id"`
			OrderID   uint      `json:"orderId"`
			UserID    uint      `json:"userId"`
			Action    string    `json:"action"`
			Status    string    `json:"status"`
			OldStatus string    `json:"oldStatus"`
			Comment   string    `json:"comment"`
			IP        string    `json:"ip"`
			CreatedAt time.Time `json:"createdAt"`
			Photos    []string  `json:"photos"`
		}
		var commitResps []CommitResponse
		for _, c := range commits {
			// Status 优先用数据库字段；若为空（历史旧数据），从 Comment 备注中截取状态
			status := c.Status
			if status == "" {
				status = strings.TrimPrefix(c.Comment, "状态变更为: ")
				status = strings.TrimPrefix(status, "变更状态为: ")
				// 如果截取后跟原文一样，说明不是"状态变更为"格式，取原文作为展示
				if status == c.Comment {
					status = ""
				}
			}
			resp := CommitResponse{
				ID:        c.ID,
				OrderID:   c.OrderID,
				UserID:    c.UserID,
				Action:    c.Action,
				Status:    status,
				OldStatus: c.OldStatus,
				Comment:   c.Comment,
				IP:        c.IP,
				CreatedAt: time.Time{},
			}
			if c.CreatedAt != nil {
				resp.CreatedAt = *c.CreatedAt
			}
			if c.Photos != "" {
				json.Unmarshal([]byte(c.Photos), &resp.Photos)
			}
			commitResps = append(commitResps, resp)
		}

		// 查询关联工单（通过 TabWorkOrderPurchaseOrderBind 表）
		type WorkOrderInfo struct {
			ID            uint   `json:"id"`
			Title         string `json:"title"`
			CurrentStatus string `json:"status"`
		}
		var linkedWorkOrders []WorkOrderInfo
		var woBinds []TabWorkOrderPurchaseOrderBind
		models.DB.Where("purchase_order_id = ?", from.ID).Find(&woBinds)
		if len(woBinds) > 0 {
			woIDSet := make(map[uint]bool)
			var woIDs []uint
			for _, wb := range woBinds {
				if !woIDSet[wb.WorkOrderID] {
					woIDSet[wb.WorkOrderID] = true
					woIDs = append(woIDs, wb.WorkOrderID)
				}
			}
			var workOrders []TabWorkOrder
			models.DB.Where("id IN ?", woIDs).Find(&workOrders)
			for _, wo := range workOrders {
				linkedWorkOrders = append(linkedWorkOrders, WorkOrderInfo{
					ID:            wo.ID,
					Title:         wo.Title,
					CurrentStatus: wo.CurrentStatus,
				})
			}
		}
		if linkedWorkOrders == nil {
			linkedWorkOrders = []WorkOrderInfo{}
		}

		// 判断当前用户是否可以修改
		canModify := canModifyPurchase(user.ID, order.UserID)

		ReturnJson(ctx, "apiOK", gin.H{
			"order":      order,
			"canModify":  canModify,
			"costs":      costs,
			"photos":     files,
			"commits":    commitResps,
			"workOrders": linkedWorkOrders,
		})
	})

	// 更新订单状态（可附带评论）
	r.POST("/updatestatus", func(ctx *gin.Context) {
		isAuth, user, data := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type FromUpdateStatus struct {
			ID      uint     `json:"id"`
			Status  string   `json:"status" binding:"required"`
			Comment string   `json:"comment"`
			Photos  []string `json:"photos"` // 变更附带的图片哈希
		}
		var from FromUpdateStatus
		if err := decodeJSON(data, &from); err != nil || from.ID == 0 {
			ReturnJson(ctx, "jsonErr", nil)
			return
		}

		// 校验图片哈希（不包含标点符号的哈希值）
		for _, hash := range from.Photos {
			if models.IsContainsSpecialChar(hash) {
				ReturnJson(ctx, "photo_hash_invalid", nil)
				return
			}
		}

		// 校验状态值
		validStatuses := map[string]bool{
			"pending":  true,
			"ordered":  true,
			"arrived":  true,
			"received": true,
			"lost":     true,
			"returned": true,
		}
		if !validStatuses[from.Status] {
			ReturnJson(ctx, "invalid_status", nil)
			return
		}

		var order TabPurchaseOrder
		if err := models.DB.Where("id = ?", from.ID).First(&order).Error; err != nil {
			ReturnJson(ctx, "order_not_found", nil)
			return
		}

		oldStatus := order.OrderStatus

		// 更新状态
		updates := map[string]interface{}{
			"order_status": from.Status,
		}
		if err := models.DB.Model(&order).Updates(updates).Error; err != nil {
			ReturnJson(ctx, "apiErr", nil)
			return
		}

		// 写状态变更 commit
		comment := from.Comment
		if comment == "" && len(from.Photos) == 0 {
			comment = "状态变更为: " + from.Status
		}
		photosJSON := ""
		if len(from.Photos) > 0 {
			if pj, err := json.Marshal(from.Photos); err == nil {
				photosJSON = string(pj)
			}
		}
		commit := TabPurchaseCommit{
			OrderID:   order.ID,
			UserID:    user.ID,
			Action:    "create_status",
			Status:    from.Status,
			OldStatus: oldStatus,
			Comment:   comment,
			Photos:    photosJSON,
			IP:        ctx.ClientIP(),
		}
		models.DB.Create(&commit)

		// 写操作日志
		newContent, _ := json.Marshal(map[string]string{
			"status":  from.Status,
			"comment": comment,
		})
		oldContent, _ := json.Marshal(map[string]string{
			"status": oldStatus,
		})
		tosqllog := TabPurchaseLog{
			UserID:     user.ID,
			OrderID:    order.ID,
			ActionType: "update_status",
			NewContent: string(newContent),
			OldContent: string(oldContent),
			IP:         ctx.ClientIP(),
			Remark:     comment,
		}
		models.DB.Create(&tosqllog)

		ReturnJson(ctx, "apiOK", nil)
	})

	// 删除状态记录
	r.POST("/delete_commit", func(ctx *gin.Context) {
		isAuth, user, data := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type FromDeleteCommit struct {
			OrderID  uint `json:"orderId"`
			CommitID uint `json:"commitId"`
		}
		var from FromDeleteCommit
		if err := decodeJSON(data, &from); err != nil || from.OrderID == 0 || from.CommitID == 0 {
			ReturnJson(ctx, "jsonErr", nil)
			return
		}

		// 获取订单信息
		var order TabPurchaseOrder
		if err := models.DB.Where("id = ?", from.OrderID).First(&order).Error; err != nil {
			ReturnJson(ctx, "order_not_found", nil)
			return
		}

		// 获取进度信息
		var commit TabPurchaseCommit
		if err := models.DB.Where("id = ? AND order_id = ?", from.CommitID, from.OrderID).First(&commit).Error; err != nil {
			ReturnJson(ctx, "commit_not_found", nil)
			return
		}

		// 权限判断：订单创建者 或 进度创建者 或 管理员
		isOrderCreator := user.ID == order.UserID
		isCommitCreator := user.ID == commit.UserID
		isAdmin := slices.Contains(purchaseAdmins, user.ID)

		if !isOrderCreator && !isCommitCreator && !isAdmin {
			ReturnJson(ctx, "no_permission", nil)
			return
		}

		// 删除进度
		models.DB.Where("id = ?", from.CommitID).Delete(&TabPurchaseCommit{})

		ReturnJson(ctx, "apiOK", nil)
	})

	r.POST("/getorders", func(ctx *gin.Context) {
		isAuth, _, data := AuthenticationAuthority(ctx)
		if isAuth {
			//fmt.Println(user)
			// DebugPrintJson(data)

			type From_purchase_getorders struct {
				Search  string
				Status  string
				Entries int
				Page    int
			}

			var jsondata From_purchase_getorders
			if err := decodeJSON(data, &jsondata); err == nil {
				//fmt.Println(jsondata)

				is_data_ok := true

				if jsondata.Entries <= 0 || jsondata.Entries > 300 {
					is_data_ok = false
				}
				if jsondata.Page <= 0 {
					is_data_ok = false
				}

				if is_data_ok {

					//读取有多少条目
					var count int64
					query := models.DB.Model(TabPurchaseOrder{})
					if jsondata.Search != "" {
						// 精确匹配订单 ID
						var id uint
						if _, err := parsefmt.Sscanf(jsondata.Search, "%d", &id); err == nil && id > 0 {
							query = query.Where("id = ?", id)
						} else {
							// 模糊匹配标题和用途（Remark）
							query = query.Where("title LIKE ? OR remark LIKE ?",
								"%"+jsondata.Search+"%", "%"+jsondata.Search+"%")
						}
					}
					if jsondata.Status != "" {
						query = query.Where("order_status = ?", jsondata.Status)
					}
					query.Count(&count)

					//读取条目
					var getorders []TabPurchaseOrder
					query.Order("updated_at DESC, id DESC").Offset(jsondata.Entries * (jsondata.Page - 1)).Limit(jsondata.Entries).Find(&getorders)

					ReturnJson(ctx, "apiOK", map[string]interface{}{
						"all_count":  count,
						"all_orders": getorders,
					})

				} else {
					ReturnJson(ctx, "jsonErr_1", nil)
				}

			} else {
				ReturnJson(ctx, "jsonErr", nil)
			}

		} else {
			ReturnJson(ctx, "userCookieError", nil)
		}
	})

	r.POST("/addorder", func(ctx *gin.Context) {
		isAuth, user, data := AuthenticationAuthority(ctx)
		if isAuth {

			//需要处理提交的数据，接口有固定的数据格式，不允许乱搞
			//fmt.Println(isAuth)
			//fmt.Println(user)
			//DebugPrintJson(data)
			var jsondata From_purchase_addorder
			//fmt.Println(data)
			if err := decodeJSON(data, &jsondata); err == nil {

				//jsonStr, _ := json.MarshalIndent(jsondata, "", "  ")
				//fmt.Println("转换后数据:\n", string(jsonStr))

				//数据比较混乱 在这里校验

				//判断标题不为空
				is_data_ok := true
				if jsondata.Title == "" {
					is_data_ok = false
				}

				//判断数量与价格是否为负数
				for i := 0; i < len(jsondata.Costs); i++ {
					if jsondata.Costs[i].Cost <= 0 {
						is_data_ok = false
					}
					if jsondata.Costs[i].Int <= 0 {
						is_data_ok = false
					}
				}

				//判断图片是否为哈希值
				for i := 0; i < len(jsondata.Photos); i++ {
					//判断字符串是否包含标点符号
					if models.IsContainsSpecialChar(jsondata.Photos[i]) {
						is_data_ok = false
						//fmt.Println("err4")
					}

				}

				//判断时间字符串是否合法
				// uptime, e := models.StringToTimePtr(jsondata.UpdateTime)
				// if e != nil {
				// 	is_data_ok = false
				// 	fmt.Println("err5")
				// }

				if is_data_ok {
					//校验通过
					//photos, _ := json.Marshal(jsondata.Photos)
					new_data := TabPurchaseOrder{
						UserID:      user.ID,
						Title:       jsondata.Title,
						Remark:      jsondata.Remark,
						Link:        jsondata.Link,
						Styles:      jsondata.Styles,
						OrderStatus: "pending", // 默认待处理
					}
					models.DB.Create(&new_data)

					for i := 0; i < len(jsondata.Costs); i++ {
						currencyType := jsondata.Costs[i].CurrencyType
						if currencyType <= 0 {
							currencyType = 1 // 默认 CNY
						}
						costType := jsondata.Costs[i].Type
						if costType <= 0 {
							costType = 1 // 默认单价
						}
						new_cost_data := TabPurchaseCosts{
							Price:        jsondata.Costs[i].Cost,
							Quantity:     jsondata.Costs[i].Int,
							UserID:       user.ID,
							OrderID:      new_data.ID,
							CurrencyType: currencyType,
							CostType:     costType,
						}
						models.DB.Create(&new_cost_data)
					}

					//绑定文件
					for i := 0; i < len(jsondata.Photos); i++ {
						findFile := TabFileInfo{
							Sha256: jsondata.Photos[i],
							Type:   "image",
						}
						if models.DB.Where(&findFile).First(&findFile).Error == nil {
							bind := TabPurchaseFileBind{
								OrderID: new_data.ID,
								FileID:  findFile.ID,
							}
							models.DB.Create(&bind)
						}
					}

					// 写创建日志
					newContent, _ := json.Marshal(jsondata)
					tosqllog := TabPurchaseLog{
						UserID:     user.ID,
						OrderID:    new_data.ID,
						ActionType: "create",
						NewContent: string(newContent),
						OldContent: "",
						IP:         ctx.ClientIP(),
					}
					models.DB.Create(&tosqllog)

					// 写状态创建 commit
					commitLog := TabPurchaseCommit{
						OrderID:   new_data.ID,
						UserID:    user.ID,
						Action:    "create",
						Status:    "pending",
						OldStatus: "",
						Comment:   "订单创建",
						IP:        ctx.ClientIP(),
					}
					models.DB.Create(&commitLog)

					ReturnJson(ctx, "apiOK", nil)

				} else {
					ReturnJson(ctx, "jsonErr_1", nil)
				}

			} else {
				ReturnJson(ctx, "jsonErr", nil)
			}

		} else {
			ReturnJson(ctx, "userCookieError", nil)
		}

		//ReturnJson(ctx, "apiErr", nil)
	})

	// 编辑订单基本信息
	r.POST("/updateorder", func(ctx *gin.Context) {
		isAuth, user, data := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type FromUpdateOrder struct {
			ID     uint       `json:"id"`
			Title  string     `json:"title"`
			Remark string     `json:"remark"`
			Link   string     `json:"link"`
			Styles string     `json:"styles"`
			Photos []string   `json:"photos"`
			Costs  []CostItem `json:"costs"`
		}
		var from FromUpdateOrder
		if err := decodeJSON(data, &from); err != nil || from.ID == 0 {
			ReturnJson(ctx, "jsonErr", nil)
			return
		}
		if from.Title == "" {
			ReturnJson(ctx, "jsonErr_1", nil)
			return
		}

		// 校验图片哈希
		for _, hash := range from.Photos {
			if models.IsContainsSpecialChar(hash) {
				ReturnJson(ctx, "photo_hash_invalid", nil)
				return
			}
		}
		// 校验费用
		for _, c := range from.Costs {
			if c.Cost <= 0 || c.Int <= 0 {
				ReturnJson(ctx, "jsonErr_1", nil)
				return
			}
		}

		var order TabPurchaseOrder
		if err := models.DB.Where("id = ?", from.ID).First(&order).Error; err != nil {
			ReturnJson(ctx, "order_not_found", nil)
			return
		}

		// 权限校验：只有创建者或管理员可以修改
		if !canModifyPurchase(user.ID, order.UserID) {
			ReturnJson(ctx, "no_permission", nil)
			return
		}

		// 记录旧数据
		oldContent, _ := json.Marshal(order)

		// 更新基本字段
		if err := models.DB.Model(&order).Updates(map[string]interface{}{
			"title":  from.Title,
			"remark": from.Remark,
			"link":   from.Link,
			"styles": from.Styles,
		}).Error; err != nil {
			ReturnJson(ctx, "apiErr", nil)
			return
		}

		// 重建费用明细：先删旧，再插新
		models.DB.Where("order_id = ?", from.ID).Delete(&TabPurchaseCosts{})
		for _, c := range from.Costs {
			ct := c.CurrencyType
			if ct <= 0 {
				ct = 1
			}
			ctype := c.Type
			if ctype <= 0 {
				ctype = 1
			}
			models.DB.Create(&TabPurchaseCosts{
				Price:        c.Cost,
				Quantity:     c.Int,
				UserID:       user.ID,
				OrderID:      from.ID,
				CurrencyType: ct,
				CostType:     ctype,
			})
		}

		// 重建图片绑定：先删旧，再插新
		models.DB.Where("order_id = ?", from.ID).Delete(&TabPurchaseFileBind{})
		for _, hash := range from.Photos {
			findFile := TabFileInfo{Sha256: hash, Type: "image"}
			if models.DB.Where(&findFile).First(&findFile).Error == nil {
				models.DB.Create(&TabPurchaseFileBind{
					OrderID: from.ID,
					FileID:  findFile.ID,
				})
			}
		}

		// 写操作日志
		newContent, _ := json.Marshal(from)
		models.DB.Create(&TabPurchaseLog{
			UserID:     user.ID,
			OrderID:    from.ID,
			ActionType: "update",
			OldContent: string(oldContent),
			NewContent: string(newContent),
			IP:         ctx.ClientIP(),
		})

		ReturnJson(ctx, "apiOK", nil)
	})

	// 删除订单
	r.POST("/deleteorder", func(ctx *gin.Context) {
		isAuth, user, data := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type FromDeleteOrder struct {
			ID uint `json:"id"`
		}
		var from FromDeleteOrder
		if err := decodeJSON(data, &from); err != nil || from.ID == 0 {
			ReturnJson(ctx, "jsonErr", nil)
			return
		}

		var order TabPurchaseOrder
		if err := models.DB.Where("id = ?", from.ID).First(&order).Error; err != nil {
			ReturnJson(ctx, "order_not_found", nil)
			return
		}

		// 权限校验：只有创建者或管理员可以删除
		if !canModifyPurchase(user.ID, order.UserID) {
			ReturnJson(ctx, "no_permission", nil)
			return
		}

		// 关联删除（硬删，不保留）
		models.DB.Where("order_id = ?", from.ID).Delete(&TabPurchaseCosts{})
		models.DB.Where("order_id = ?", from.ID).Delete(&TabPurchaseFileBind{})
		models.DB.Where("order_id = ?", from.ID).Delete(&TabPurchaseCommit{})
		models.DB.Where("order_id = ?", from.ID).Delete(&TabPurchaseLog{})

		// 软删除订单本身
		models.DB.Delete(&order)

		ReturnJson(ctx, "apiOK", nil)
	})

	// 获取订单数量统计
	r.POST("/getordercount", func(ctx *gin.Context) {
		isAuth, _, _ := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type OrderCount struct {
			Pending  int64 `json:"pending"`  // 待处理
			Ordered  int64 `json:"ordered"`  // 已下单
			Arrived  int64 `json:"arrived"`  // 已到达
			Received int64 `json:"received"` // 已收件
			Lost     int64 `json:"lost"`     // 丢件
			Returned int64 `json:"returned"` // 退件
			Total    int64 `json:"total"`    // 总数
		}

		var count OrderCount
		models.DB.Model(&TabPurchaseOrder{}).Count(&count.Total)
		models.DB.Model(&TabPurchaseOrder{}).Where("order_status = ?", "pending").Count(&count.Pending)
		models.DB.Model(&TabPurchaseOrder{}).Where("order_status = ?", "ordered").Count(&count.Ordered)
		models.DB.Model(&TabPurchaseOrder{}).Where("order_status = ?", "arrived").Count(&count.Arrived)
		models.DB.Model(&TabPurchaseOrder{}).Where("order_status = ?", "received").Count(&count.Received)
		models.DB.Model(&TabPurchaseOrder{}).Where("order_status = ?", "lost").Count(&count.Lost)
		models.DB.Model(&TabPurchaseOrder{}).Where("order_status = ?", "returned").Count(&count.Returned)

		ReturnJson(ctx, "apiOK", map[string]interface{}{
			"pending":  count.Pending,
			"ordered":  count.Ordered,
			"arrived":  count.Arrived,
			"received": count.Received,
			"lost":     count.Lost,
			"returned": count.Returned,
			"total":    count.Total,
		})
	})

	// 搜索工单（用于采购订单关联）
	r.POST("/search_work_orders", func(ctx *gin.Context) {
		isAuth, _, data := AuthenticationAuthority(ctx)
		if !isAuth {
			ReturnJson(ctx, "userCookieError", nil)
			return
		}

		type FromSearch struct {
			Search string `json:"search"`
			Limit  int    `json:"limit"`
		}
		var from FromSearch
		if err := decodeJSON(data, &from); err != nil {
			ReturnJson(ctx, "jsonErr", nil)
			return
		}
		if from.Limit <= 0 || from.Limit > 20 {
			from.Limit = 5
		}

		query := models.DB.Model(&TabWorkOrder{})
		if from.Search != "" {
			var id uint
			if _, err := parsefmt.Sscanf(from.Search, "%d", &id); err == nil && id > 0 {
				query = query.Where("id = ?", id)
			} else {
				query = query.Where("title LIKE ? OR description LIKE ?",
					"%"+from.Search+"%", "%"+from.Search+"%")
			}
		}

		var orders []TabWorkOrder
		query.Order("updated_at DESC, id DESC").Limit(from.Limit).Find(&orders)

		type WorkOrderInfo struct {
			ID     uint   `json:"id"`
			Title  string `json:"title"`
			Status string `json:"status"`
		}
		var result []WorkOrderInfo
		for _, o := range orders {
			result = append(result, WorkOrderInfo{
				ID:     o.ID,
				Title:  o.Title,
				Status: o.CurrentStatus,
			})
		}
		if result == nil {
			result = []WorkOrderInfo{}
		}

		ReturnJson(ctx, "apiOK", gin.H{"orders": result})
	})

}