package dnfbridge

import (
	"context"
	"errors"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

	dnfauction "longheng.io/server/internal/modules/dnf/auction"
	dnfrepo "longheng.io/server/internal/modules/dnf/repository"
)

// GM 拍卖行接口。
//
// 服务端的拍卖行没有面向工具的 GM 能力，但 dnfauction.Owner 已经提供
// 不依赖玩家 session 的纯数据层方法（Register / Cancel / Search /
// LoadListing）。本文件把它们包成 GM 工具可直接调用的接口，供「线上
// 上架/下架」使用 —— 与 GM 工具 SQLite 直读的路径互补：服务端在线时走
// 这里（由服务端事务保证一致），停服时走 SQLite 直读。

// 高位段挂单 ID：服务端玩家路径的 ID 来自进程内计数器（重启后从当前
// Unix 时间戳重新开始），GM 工具若占用小 ID，重启后的服务端连续撞号会
// 上架失败。因此 GM 挂单统一落在 9e18 起的高位段，永不与玩家路径冲突。
const gmAuctionListingIDBase uint64 = 9000000000000000000

// gmAuctionListingPrefix 与 owner.go 的 listingPrefix 保持一致（该常量未导出）。
const gmAuctionListingPrefix = "auction:listing:"

// GMAuctionListing 是给 GM 工具看的挂单视图。
type GMAuctionListing struct {
	ListingID   uint64 `json:"listing_id"`
	ItemID      int64  `json:"item_id"`
	Count       int64  `json:"count"`
	SellerID    string `json:"seller_id"`
	SellerName  string `json:"seller_name"`
	ListType    byte   `json:"list_type"`
	SourceSlot  int16  `json:"source_slot"`
	UnitPrice   int64  `json:"unit_price"`
	StartPrice  int64  `json:"start_price"`
	BuyoutPrice int64  `json:"buyout_price"`
	Deposit     int64  `json:"deposit"`
	FeePercent  int64  `json:"fee_percent"`
	BidTotal    int64  `json:"bid_total"`
	BidderID    string `json:"bidder_id"`
	CreatedAt   int64  `json:"created_at"`
	ExpiresAt   int64  `json:"expires_at"`
	Expired     bool   `json:"expired"`
}

// GMAuctionListingsResult 是列出挂单的返回。
type GMAuctionListingsResult struct {
	Listings   []GMAuctionListing `json:"listings"`
	EscrowGold int64              `json:"escrow_gold"`
}

// GMAuctionListRequest 是 GM 上架请求。
type GMAuctionListRequest struct {
	SellerID      string `json:"seller_id"`
	SellerName    string `json:"seller_name"`
	ItemID        int64  `json:"item_id"`
	Count         int64  `json:"count"`
	UnitPrice     int64  `json:"unit_price"`
	StartPrice    int64  `json:"start_price"`    // 每件起拍价，-1 表示不设竞拍
	BuyoutPrice   int64  `json:"buyout_price"`   // 每件一口价，-1 表示不设一口价
	DurationHours int64  `json:"duration_hours"` // 24 或 48
	GrantIfMissing bool  `json:"grant_if_missing,omitempty"` // 背包不足时自动发放差额（发放式上架）
}

// GMAuctionListResult 是 GM 上架结果。
type GMAuctionListResult struct {
	ListingID       uint64 `json:"listing_id"`
	ItemID          int64  `json:"item_id"`
	Count           int64  `json:"count"`
	UnitPrice       int64  `json:"unit_price"`
	StartPrice      int64  `json:"start_price"`
	BuyoutPrice     int64  `json:"buyout_price"`
	Deposit         int64  `json:"deposit"`
	FeePercent      int64  `json:"fee_percent"`
	ExpiresAt       int64  `json:"expires_at"`
	SellerGoldAfter int64  `json:"seller_gold_after"`
}

// GMAuctionCancelRequest 是 GM 下架请求。
type GMAuctionCancelRequest struct {
	ListingID uint64 `json:"listing_id"`
}

// GMAuctionCancelResult 是 GM 下架结果。
type GMAuctionCancelResult struct {
	ListingID        uint64 `json:"listing_id"`
	ItemID           int64  `json:"item_id"`
	Count            int64  `json:"count"`
	SellerID         string `json:"seller_id"`
	DepositForfeited int64  `json:"deposit_forfeited"`
	RefundGold       int64  `json:"refund_gold"` // 有竞价时退给竞价者的金额
	RefundBidder     string `json:"refund_bidder"`
}

// gmAuctionOwner 构造一个拍卖行 Owner 并返回 repositories。
func (s *Service) gmAuctionOwner() (*dnfauction.Owner, dnfrepo.Group, error) {
	if s == nil {
		return nil, dnfrepo.Group{}, dnfauction.ErrUnavailable
	}
	repositories, ok := s.repositoryGroup()
	if !ok {
		return nil, dnfrepo.Group{}, dnfauction.ErrUnavailable
	}
	owner, err := dnfauction.NewOwner(repositories)
	if err != nil {
		return nil, dnfrepo.Group{}, err
	}
	return owner, repositories, nil
}

// gmAuctionNextID 返回一个高位段挂单 ID。它从 9e18 起单调递增，且跳过
// escrow 里已经占用的 ID（含已产生投递/退款的历史 ID，避免复用）。
func gmAuctionNextID(escrow dnfrepo.InventoryRecord) uint64 {
	best := gmAuctionListingIDBase - 1
	for key := range escrow.Slots {
		if !strings.HasPrefix(key, gmAuctionListingPrefix) {
			continue
		}
		raw := strings.TrimPrefix(key, gmAuctionListingPrefix)
		if id, err := strconv.ParseUint(raw, 10, 64); err == nil && id >= gmAuctionListingIDBase && id > best {
			best = id
		}
	}
	return best + 1
}

func gmAuctionListingView(l dnfauction.Listing) GMAuctionListing {
	now := time.Now()
	return GMAuctionListing{
		ListingID:   l.ID,
		ItemID:      l.Item.ItemID,
		Count:       l.Item.Count,
		SellerID:    l.SellerID,
		SellerName:  l.SellerName,
		ListType:    l.ListType,
		SourceSlot:  l.SourceSlot,
		UnitPrice:   l.UnitPrice,
		StartPrice:  l.StartPrice,
		BuyoutPrice: l.BuyoutPrice,
		Deposit:     l.Deposit,
		FeePercent:  l.FeePercent,
		BidTotal:    l.BidTotal,
		BidderID:    l.BidderID,
		CreatedAt:   l.CreatedAt.Unix(),
		ExpiresAt:   l.ExpiresAt.Unix(),
		Expired:     !l.ExpiresAt.IsZero() && l.ExpiresAt.Before(now),
	}
}

// GMAuctionListings 列出所有挂单（含已过期），供 GM 工具展示与下架。
func (s *Service) GMAuctionListings(ctx context.Context) (GMAuctionListingsResult, error) {
	result := GMAuctionListingsResult{Listings: make([]GMAuctionListing, 0)}
	owner, repositories, err := s.gmAuctionOwner()
	if err != nil {
		return result, err
	}
	if err := owner.EnsureEscrow(ctx); err != nil {
		return result, err
	}
	escrow, found, err := repositories.Inventory.Load(ctx, dnfauction.EscrowCharacterID)
	if err != nil {
		return result, err
	}
	if !found {
		return result, nil
	}
	// 托管角色金币
	if escrowChar, charFound, charErr := repositories.Character.Load(ctx, dnfauction.EscrowCharacterID); charErr == nil && charFound {
		result.EscrowGold = escrowChar.Stats["gold"]
	}
	for key := range escrow.Slots {
		if !strings.HasPrefix(key, gmAuctionListingPrefix) {
			continue
		}
		id, parseErr := strconv.ParseUint(strings.TrimPrefix(key, gmAuctionListingPrefix), 10, 64)
		if parseErr != nil {
			continue
		}
		listing, loadErr := owner.LoadListing(ctx, id)
		if loadErr != nil {
			continue
		}
		result.Listings = append(result.Listings, gmAuctionListingView(listing))
	}
	sort.Slice(result.Listings, func(i, j int) bool {
		return result.Listings[i].ListingID > result.Listings[j].ListingID
	})
	return result, nil
}

// GMAuctionList 上架一件物品。行为对齐玩家路径，但不依赖 session：
// 押金 10000、标准手续费 5%、时长 24/48 小时、主背包（list 0）为来源。
func (s *Service) GMAuctionList(ctx context.Context, request GMAuctionListRequest) (GMAuctionListResult, error) {
	var result GMAuctionListResult
	owner, repositories, err := s.gmAuctionOwner()
	if err != nil {
		return result, err
	}
	if err := owner.EnsureEscrow(ctx); err != nil {
		return result, err
	}

	// 解析卖家
	sellerID := strings.TrimSpace(request.SellerID)
	if sellerID == "" {
		return result, fmt.Errorf("%w: seller is required", ErrGMRequestInvalid)
	}
	seller, err := s.gmCharacter(ctx, repositories, sellerID, request.SellerName)
	if err != nil {
		return result, err
	}
	if seller.CharacterID == dnfauction.EscrowCharacterID {
		return result, fmt.Errorf("%w: cannot list from escrow", ErrGMRequestInvalid)
	}

	// 参数校验
	if request.ItemID <= 0 || request.Count <= 0 || request.UnitPrice <= 0 {
		return result, fmt.Errorf("%w: item_id/count/unit_price must be positive", ErrGMRequestInvalid)
	}
	if request.StartPrice < -1 || request.StartPrice > request.UnitPrice {
		return result, fmt.Errorf("%w: start_price must be -1 or in [0, unit_price]", ErrGMRequestInvalid)
	}
	buyoutPrice := request.BuyoutPrice
	if buyoutPrice == 0 {
		buyoutPrice = request.UnitPrice
	}
	if buyoutPrice == -1 {
		if request.StartPrice != request.UnitPrice {
			return result, fmt.Errorf("%w: buyout-only listing requires start_price == unit_price", ErrGMRequestInvalid)
		}
	} else if buyoutPrice != request.UnitPrice {
		return result, fmt.Errorf("%w: buyout_price must equal unit_price", ErrGMRequestInvalid)
	}
	durationHours := request.DurationHours
	if durationHours != 24 && durationHours != 48 {
		return result, fmt.Errorf("%w: duration_hours must be 24 or 48", ErrGMRequestInvalid)
	}

	// 从卖家背包找满足条件的物品槽（主背包 list 0）
	inventory, found, err := repositories.Inventory.Load(ctx, seller.CharacterID)
	if err != nil {
		return result, err
	}
	if !found {
		return result, ErrGMInventoryNotFound
	}
	sourceSlot, stack, ok := gmFindStackableSourceSlot(inventory.Slots, request.ItemID, request.Count)
	if !ok && request.GrantIfMissing {
		// 发放式上架：背包不足时，先凭空发放差额（复用 GMGrantItem 的
		// 副本拾取发放路径，物品名/绑定/容器格位均由 PVF 目录正确推导），
		// 再重新读背包找槽。
		have := int64(0)
		for key, st := range inventory.Slots {
			parts := strings.SplitN(key, ":", 2)
			if len(parts) == 2 && parts[0] == "0" && st.ItemID == request.ItemID {
				have += st.Count
			}
		}
		shortage := request.Count - have
		if shortage > 0 {
			if _, err := s.GMGrantItem(ctx, GMItemGrantRequest{
				CharacterID: seller.CharacterID,
				ItemID:      uint32(request.ItemID),
				Count:       uint32(shortage),
			}); err != nil {
				return result, fmt.Errorf("%w: 自动补足发放失败: %v", ErrGMItemRowNotFound, err)
			}
			inventory, found, err = repositories.Inventory.Load(ctx, seller.CharacterID)
			if err != nil {
				return result, err
			}
			if !found {
				return result, ErrGMInventoryNotFound
			}
			sourceSlot, stack, ok = gmFindStackableSourceSlot(inventory.Slots, request.ItemID, request.Count)
		}
	}
	if !ok {
		return result, fmt.Errorf("%w: item %d not found in seller bag with enough count", ErrGMItemRowNotFound, request.ItemID)
	}

	// 分配高位段挂单 ID，撞号时刷新 escrow 重试
	escrow, _, err := repositories.Inventory.Load(ctx, dnfauction.EscrowCharacterID)
	if err != nil {
		return result, err
	}
	var listingID uint64
	var registerResult dnfauction.Result
	for attempts := 0; attempts < 8; attempts++ {
		listingID = gmAuctionNextID(escrow)
		registerResult, err = owner.Register(ctx, dnfauction.RegisterCommand{
			ListingID: listingID, SellerID: seller.CharacterID,
			AccountID: strings.TrimSpace(seller.AccountID), SellerName: seller.Name,
			ListType: 0, SourceSlot: sourceSlot, ExpectedID: request.ItemID,
			Count: request.Count, UnitPrice: request.UnitPrice,
			StartPrice: request.StartPrice, BuyoutPrice: buyoutPrice,
			Deposit: 0, FeePercent: dnfauction.SaleFeePercentFor(false),
			Duration: time.Duration(durationHours) * time.Hour, ListingLimit: 5,
			ExpectedBind: stack.Bind, AllowSealed: false,
		})
		if !errors.Is(err, dnfauction.ErrListingIDExists) {
			break
		}
		escrow, _, err = repositories.Inventory.Load(ctx, dnfauction.EscrowCharacterID)
		if err != nil {
			return result, err
		}
	}
	if err != nil {
		return result, err
	}

	result = GMAuctionListResult{
		ListingID:       registerResult.Listing.ID,
		ItemID:          registerResult.Listing.Item.ItemID,
		Count:           registerResult.Listing.Item.Count,
		UnitPrice:       registerResult.Listing.UnitPrice,
		StartPrice:      registerResult.Listing.StartPrice,
		BuyoutPrice:     registerResult.Listing.BuyoutPrice,
		Deposit:         registerResult.Listing.Deposit,
		FeePercent:      registerResult.Listing.FeePercent,
		ExpiresAt:       registerResult.Listing.ExpiresAt.Unix(),
		SellerGoldAfter: registerResult.GoldAfter,
	}
	return result, nil
}

// gmFindStackableSourceSlot 在主背包（list 0）里找一个 item_id 匹配且数量足够
// 的槽位，返回槽号与物品。
func gmFindStackableSourceSlot(slots map[string]dnfrepo.ItemStack, itemID, count int64) (int16, dnfrepo.ItemStack, bool) {
	for key, stack := range slots {
		parts := strings.SplitN(key, ":", 2)
		if len(parts) != 2 || parts[0] != "0" {
			continue
		}
		slot, err := strconv.ParseInt(parts[1], 10, 16)
		if err != nil {
			continue
		}
		if stack.ItemID == itemID && stack.Count >= count {
			return int16(slot), stack, true
		}
	}
	return 0, dnfrepo.ItemStack{}, false
}

// GMAuctionCancel 下架一件挂单。行为对齐 Owner.Cancel：物品退回卖家（游戏内
// 走邮件），押金不退；若有竞价则退款给竞价者。
func (s *Service) GMAuctionCancel(ctx context.Context, request GMAuctionCancelRequest) (GMAuctionCancelResult, error) {
	var result GMAuctionCancelResult
	if request.ListingID == 0 {
		return result, fmt.Errorf("%w: listing_id is required", ErrGMRequestInvalid)
	}
	owner, repositories, err := s.gmAuctionOwner()
	if err != nil {
		return result, err
	}
	if err := owner.EnsureEscrow(ctx); err != nil {
		return result, err
	}
	// 先读出挂单，拿到卖家与物品信息
	listing, err := owner.LoadListing(ctx, request.ListingID)
	if err != nil {
		return result, err
	}
	// 卖家账号（Cancel 需要 AccountID 校验归属）
	seller, sellerFound, err := repositories.Character.Load(ctx, listing.SellerID)
	if err != nil {
		return result, err
	}
	if !sellerFound {
		return result, ErrGMCharacterNotFound
	}
	cancelResult, err := owner.Cancel(ctx, dnfauction.CancelCommand{
		SellerID:  listing.SellerID,
		AccountID: strings.TrimSpace(seller.AccountID),
		ListingID: request.ListingID,
	})
	if err != nil {
		return result, err
	}

	result = GMAuctionCancelResult{
		ListingID:        request.ListingID,
		ItemID:           listing.Item.ItemID,
		Count:            listing.Item.Count,
		SellerID:         listing.SellerID,
		DepositForfeited: listing.Deposit,
	}
	if cancelResult.Refund.ID != "" {
		result.RefundGold = cancelResult.Refund.Gold
		result.RefundBidder = cancelResult.Refund.SellerID
	}
	return result, nil
}

// GMInventoryRow 是 GM 工具「背包管理」里的单行条目（背包行或穿戴行）。
type GMInventoryRow struct {
	Collection string `json:"collection"` // "slots"（背包）或 "wear"（穿戴）
	EntryKey   string `json:"entry_key"`  // "list_type:slot" 或 "slot"
	ItemID     int64  `json:"item_id"`
	Count      int64  `json:"count"`
	Bind       bool   `json:"bind"`
	ItemName   string `json:"item_name,omitempty"`
}

// GMInventoryListResult 是列背包的返回。
type GMInventoryListResult struct {
	CharacterID string          `json:"character_id"`
	Rows        []GMInventoryRow `json:"rows"`
}

// GMInventoryList 列出角色背包所有行 + 穿戴装备行，供 GM 工具展示与删除。
// 与 GMDeleteItemV2（按 entry_key 删除）配合使用。
func (s *Service) GMInventoryList(ctx context.Context, characterID string) (GMInventoryListResult, error) {
	result := GMInventoryListResult{}
	if s == nil {
		return result, ErrGMItemGrantUnavailable
	}
	if ctx == nil {
		ctx = context.Background()
	}
	characterID = strings.TrimSpace(characterID)
	if characterID == "" {
		return result, fmt.Errorf("%w: character_id is required", ErrGMRequestInvalid)
	}
	result.CharacterID = characterID

	repositories, available := s.repositoryGroup()
	if !available || repositories.Inventory == nil {
		return result, ErrGMRepositoryUnavailable
	}

	// 物品名解析（失败时留空，前端兜底显示 item_id）
	var catalog *pvfDungeonDropCatalog
	if c, err := s.currentPVFItemCatalog(); err == nil {
		catalog = c
	}
	itemName := func(itemID int64) string {
		if catalog == nil {
			return ""
		}
		if def, err := catalog.ResolveItem(uint32(itemID)); err == nil {
			return def.Name
		}
		return ""
	}

	// 背包行
	inventory, found, err := repositories.Inventory.Load(ctx, characterID)
	if err != nil {
		return result, err
	}
	if found {
		keys := make([]string, 0, len(inventory.Slots))
		for key := range inventory.Slots {
			keys = append(keys, key)
		}
		sort.Strings(keys)
		for _, key := range keys {
			stack := inventory.Slots[key]
			result.Rows = append(result.Rows, GMInventoryRow{
				Collection: "slots",
				EntryKey:   key,
				ItemID:     stack.ItemID,
				Count:      stack.Count,
				Bind:       stack.Bind,
				ItemName:   itemName(stack.ItemID),
			})
		}
	}

	// 穿戴装备行
	if repositories.Equipment != nil {
		equip, found, err := repositories.Equipment.Load(ctx, characterID)
		if err != nil {
			return result, err
		}
		if found {
			keys := make([]string, 0, len(equip.Entries))
			for key := range equip.Entries {
				keys = append(keys, key)
			}
			sort.Strings(keys)
			for _, key := range keys {
				entry := equip.Entries[key]
				result.Rows = append(result.Rows, GMInventoryRow{
					Collection: "wear",
					EntryKey:   key,
					ItemID:     entry.ItemID,
					Count:      1,
					Bind:       entry.Bind,
					ItemName:   itemName(entry.ItemID),
				})
			}
		}
	}

	return result, nil
}