package repository

import (
	"github.com/rovina/zsp-backend/internal/model"
	"gorm.io/gorm"
)

// ----- 我要提货 -----
func CreateDeliveryApply(db *gorm.DB, e *model.DeliveryApply) error { return db.Create(e).Error }
func ListDeliveryApply(db *gorm.DB, page, pageSize int, orderNumber, blNumber, status string) ([]model.DeliveryApply, int64, error) {
	var list []model.DeliveryApply
	q := db.Model(&model.DeliveryApply{})
	if orderNumber != "" {
		q = q.Where("order_number LIKE ?", "%"+orderNumber+"%")
	}
	if blNumber != "" {
		q = q.Where("bl_number LIKE ?", "%"+blNumber+"%")
	}
	if status != "" {
		q = q.Where("status = ?", status)
	}
	var total int64
	if err := q.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	offset := (page - 1) * pageSize
	if offset < 0 {
		offset = 0
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	err := q.Order("create_time DESC").Offset(offset).Limit(pageSize).Find(&list).Error
	return list, total, err
}
func GetDeliveryApplyByID(db *gorm.DB, id uint) (*model.DeliveryApply, error) {
	var e model.DeliveryApply
	if err := db.First(&e, id).Error; err != nil {
		return nil, err
	}
	return &e, nil
}
func UpdateDeliveryApply(db *gorm.DB, e *model.DeliveryApply) error { return db.Save(e).Error }
func DeleteDeliveryApply(db *gorm.DB, id uint) error                 { return db.Delete(&model.DeliveryApply{}, id).Error }

// ----- 提货明细/出库单 -----
func CreateDeliveryOutbound(db *gorm.DB, e *model.DeliveryOutbound) error { return db.Create(e).Error }
func ListDeliveryOutbound(db *gorm.DB, page, pageSize int, outboundNumber, blNumber, status string) ([]model.DeliveryOutbound, int64, error) {
	var list []model.DeliveryOutbound
	q := db.Model(&model.DeliveryOutbound{})
	if outboundNumber != "" {
		q = q.Where("outbound_number LIKE ?", "%"+outboundNumber+"%")
	}
	if blNumber != "" {
		q = q.Where("bl_number LIKE ?", "%"+blNumber+"%")
	}
	if status != "" {
		q = q.Where("outbound_status = ?", status)
	}
	var total int64
	if err := q.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	offset := (page - 1) * pageSize
	if offset < 0 {
		offset = 0
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	err := q.Order("create_time DESC").Offset(offset).Limit(pageSize).Find(&list).Error
	return list, total, err
}
func GetDeliveryOutboundByID(db *gorm.DB, id uint) (*model.DeliveryOutbound, error) {
	var e model.DeliveryOutbound
	if err := db.First(&e, id).Error; err != nil {
		return nil, err
	}
	return &e, nil
}
func UpdateDeliveryOutbound(db *gorm.DB, e *model.DeliveryOutbound) error { return db.Save(e).Error }
func DeleteDeliveryOutbound(db *gorm.DB, id uint) error                  { return db.Delete(&model.DeliveryOutbound{}, id).Error }

// ----- 仓库 -----
func CreateWarehouse(db *gorm.DB, e *model.Warehouse) error   { return db.Create(e).Error }
func ListWarehouses(db *gorm.DB) ([]model.Warehouse, error)   { var list []model.Warehouse; err := db.Order("create_time DESC").Find(&list).Error; return list, err }
func GetWarehouseByID(db *gorm.DB, id uint) (*model.Warehouse, error) {
	var e model.Warehouse
	if err := db.First(&e, id).Error; err != nil {
		return nil, err
	}
	return &e, nil
}
func UpdateWarehouse(db *gorm.DB, e *model.Warehouse) error { return db.Save(e).Error }
func DeleteWarehouse(db *gorm.DB, id uint) error           { return db.Delete(&model.Warehouse{}, id).Error }

// ----- 入库单 -----
func CreateInventoryInbound(db *gorm.DB, e *model.InventoryInbound) error { return db.Create(e).Error }
func ListInventoryInbound(db *gorm.DB, page, pageSize int, warehouse, commodity string) ([]model.InventoryInbound, int64, error) {
	var list []model.InventoryInbound
	q := db.Model(&model.InventoryInbound{})
	if warehouse != "" {
		q = q.Where("warehouse = ?", warehouse)
	}
	if commodity != "" {
		q = q.Where("commodity LIKE ?", "%"+commodity+"%")
	}
	var total int64
	if err := q.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	offset := (page - 1) * pageSize
	if offset < 0 {
		offset = 0
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	err := q.Order("create_time DESC").Offset(offset).Limit(pageSize).Find(&list).Error
	return list, total, err
}
func GetInventoryInboundByID(db *gorm.DB, id uint) (*model.InventoryInbound, error) {
	var e model.InventoryInbound
	if err := db.First(&e, id).Error; err != nil {
		return nil, err
	}
	return &e, nil
}
func UpdateInventoryInbound(db *gorm.DB, e *model.InventoryInbound) error { return db.Save(e).Error }
func DeleteInventoryInbound(db *gorm.DB, id uint) error                   { return db.Delete(&model.InventoryInbound{}, id).Error }

// ----- 货权转移 -----
func CreateOwnershipTransfer(db *gorm.DB, e *model.OwnershipTransfer) error {
	return db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(e).Error; err != nil {
			return err
		}
		// Set TransferID for BL items after main record is created
		for i := range e.BLItems {
			e.BLItems[i].TransferID = e.ID
		}
		if len(e.BLItems) > 0 {
			return tx.Create(&e.BLItems).Error
		}
		return nil
	})
}
func ListOwnershipTransfer(db *gorm.DB, page, pageSize int, transferNumber, blNumber, status string) ([]model.OwnershipTransfer, int64, error) {
	var list []model.OwnershipTransfer
	q := db.Model(&model.OwnershipTransfer{})
	if transferNumber != "" {
		q = q.Where("transfer_number LIKE ?", "%"+transferNumber+"%")
	}
	if blNumber != "" {
		q = q.Where("id IN (SELECT transfer_id FROM ownership_transfer_bls WHERE bl_number LIKE ?)", "%"+blNumber+"%")
	}
	if status != "" {
		q = q.Where("status = ?", status)
	}
	var total int64
	if err := q.Count(&total).Error; err != nil {
		return nil, 0, err
	}
	offset := (page - 1) * pageSize
	if offset < 0 {
		offset = 0
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	err := q.Preload("Files").Preload("BLItems").Order("create_time DESC").Offset(offset).Limit(pageSize).Find(&list).Error
	return list, total, err
}
func GetOwnershipTransferByID(db *gorm.DB, id uint) (*model.OwnershipTransfer, error) {
	var e model.OwnershipTransfer
	if err := db.Preload("Files").Preload("BLItems").First(&e, id).Error; err != nil {
		return nil, err
	}
	return &e, nil
}
func UpdateOwnershipTransfer(db *gorm.DB, e *model.OwnershipTransfer) error {
	return db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Save(e).Error; err != nil {
			return err
		}
		// Replace BL items: delete old, insert new
		if err := tx.Where("transfer_id = ?", e.ID).Delete(&model.OwnershipTransferBL{}).Error; err != nil {
			return err
		}
		for i := range e.BLItems {
			e.BLItems[i].ID = 0
			e.BLItems[i].TransferID = e.ID
		}
		if len(e.BLItems) > 0 {
			return tx.Create(&e.BLItems).Error
		}
		return nil
	})
}
func DeleteOwnershipTransfer(db *gorm.DB, id uint) error {
	return db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Where("transfer_id = ?", id).Delete(&model.OwnershipTransferFile{}).Error; err != nil {
			return err
		}
		if err := tx.Where("transfer_id = ?", id).Delete(&model.OwnershipTransferBL{}).Error; err != nil {
			return err
		}
		return tx.Delete(&model.OwnershipTransfer{}, id).Error
	})
}
func CreateOwnershipTransferFiles(db *gorm.DB, files []model.OwnershipTransferFile) error {
	if len(files) == 0 {
		return nil
	}
	return db.Create(&files).Error
}

// DeliveryRepository wraps *gorm.DB and exposes all delivery-related repository methods
type DeliveryRepository struct {
	db *gorm.DB
}

func NewDeliveryRepository(db *gorm.DB) *DeliveryRepository {
	return &DeliveryRepository{db: db}
}

func (r *DeliveryRepository) CreateDeliveryApply(e *model.DeliveryApply) error { return CreateDeliveryApply(r.db, e) }
func (r *DeliveryRepository) ListDeliveryApply(page, pageSize int, orderNumber, blNumber, status string) ([]model.DeliveryApply, int64, error) {
	return ListDeliveryApply(r.db, page, pageSize, orderNumber, blNumber, status)
}
func (r *DeliveryRepository) GetDeliveryApplyByID(id uint) (*model.DeliveryApply, error) { return GetDeliveryApplyByID(r.db, id) }
func (r *DeliveryRepository) UpdateDeliveryApply(e *model.DeliveryApply) error           { return UpdateDeliveryApply(r.db, e) }
func (r *DeliveryRepository) DeleteDeliveryApply(id uint) error                          { return DeleteDeliveryApply(r.db, id) }

func (r *DeliveryRepository) CreateDeliveryOutbound(e *model.DeliveryOutbound) error { return CreateDeliveryOutbound(r.db, e) }
func (r *DeliveryRepository) ListDeliveryOutbound(page, pageSize int, outboundNumber, blNumber, status string) ([]model.DeliveryOutbound, int64, error) {
	return ListDeliveryOutbound(r.db, page, pageSize, outboundNumber, blNumber, status)
}
func (r *DeliveryRepository) GetDeliveryOutboundByID(id uint) (*model.DeliveryOutbound, error) { return GetDeliveryOutboundByID(r.db, id) }
func (r *DeliveryRepository) UpdateDeliveryOutbound(e *model.DeliveryOutbound) error            { return UpdateDeliveryOutbound(r.db, e) }
func (r *DeliveryRepository) DeleteDeliveryOutbound(id uint) error                              { return DeleteDeliveryOutbound(r.db, id) }

func (r *DeliveryRepository) CreateWarehouse(e *model.Warehouse) error   { return CreateWarehouse(r.db, e) }
func (r *DeliveryRepository) ListWarehouses() ([]model.Warehouse, error) { return ListWarehouses(r.db) }
func (r *DeliveryRepository) GetWarehouseByID(id uint) (*model.Warehouse, error) { return GetWarehouseByID(r.db, id) }
func (r *DeliveryRepository) UpdateWarehouse(e *model.Warehouse) error    { return UpdateWarehouse(r.db, e) }
func (r *DeliveryRepository) DeleteWarehouse(id uint) error              { return DeleteWarehouse(r.db, id) }

func (r *DeliveryRepository) CreateInventoryInbound(e *model.InventoryInbound) error { return CreateInventoryInbound(r.db, e) }
func (r *DeliveryRepository) ListInventoryInbound(page, pageSize int, warehouse, commodity string) ([]model.InventoryInbound, int64, error) {
	return ListInventoryInbound(r.db, page, pageSize, warehouse, commodity)
}
func (r *DeliveryRepository) GetInventoryInboundByID(id uint) (*model.InventoryInbound, error) { return GetInventoryInboundByID(r.db, id) }
func (r *DeliveryRepository) UpdateInventoryInbound(e *model.InventoryInbound) error            { return UpdateInventoryInbound(r.db, e) }
func (r *DeliveryRepository) DeleteInventoryInbound(id uint) error                              { return DeleteInventoryInbound(r.db, id) }

func (r *DeliveryRepository) CreateOwnershipTransfer(e *model.OwnershipTransfer) error { return CreateOwnershipTransfer(r.db, e) }
func (r *DeliveryRepository) ListOwnershipTransfer(page, pageSize int, transferNumber, blNumber, status string) ([]model.OwnershipTransfer, int64, error) {
	return ListOwnershipTransfer(r.db, page, pageSize, transferNumber, blNumber, status)
}
func (r *DeliveryRepository) GetOwnershipTransferByID(id uint) (*model.OwnershipTransfer, error) { return GetOwnershipTransferByID(r.db, id) }
func (r *DeliveryRepository) UpdateOwnershipTransfer(e *model.OwnershipTransfer) error            { return UpdateOwnershipTransfer(r.db, e) }
func (r *DeliveryRepository) DeleteOwnershipTransfer(id uint) error                              { return DeleteOwnershipTransfer(r.db, id) }
func (r *DeliveryRepository) CreateOwnershipTransferFiles(files []model.OwnershipTransferFile) error {
	return CreateOwnershipTransferFiles(r.db, files)
}

// DB returns the underlying *gorm.DB for complex queries (e.g. InventorySummary)
func (r *DeliveryRepository) DB() *gorm.DB { return r.db }