cmautobuy/admin/service/inner_code_import.go

package service

import (
	"bytes"
	"database/sql"
	"errors"
	"fmt"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"time"
	"unicode/utf8"

	"github.com/xuri/excelize/v2"

	"cmautobuy/admin/model"
	"cmautobuy/admin/repository"
)

const (
	MaxInnerCodeUploadBytes = 10 * 1024 * 1024
	MaxInnerCodeImportRows  = 5000
	innerCodeSheetName      = "标签入库码映射"
)

var (
	ErrInvalidInnerCodeImport = errors.New("档口入库码导入文件无效")
	innerCodeXLSXMagic        = []byte{0x50, 0x4B, 0x03, 0x04}
	innerCodeBracketCN        = regexp.MustCompile(`【[^】]*】`)
	innerCodeParenthesesCN    = regexp.MustCompile(`（[^）]*）`)
	innerCodeParenthesesASCII = regexp.MustCompile(`\([^)]*\)`)
	innerCodeSuggestionTail   = regexp.MustCompile(`建議.*$`)
	innerCodeSpaces           = regexp.MustCompile(`\s+`)
	innerCodeStallToken       = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9-]*$`)
	innerCodeWeightTail       = regexp.MustCompile(`(?i)[\d.]+[-~～到至][\d.]+(?:公斤|kg).*$`)
	innerCodeSizeTail         = regexp.MustCompile(`(?i)((?:[1-9]\d*)?XL|XXL|XS|S|M|L)$`)
)

// InnerCodeImportResult 是一次单表幂等导入的统计。
type InnerCodeImportResult struct {
	TotalRows     int
	CreatedCount  int
	UpdatedCount  int
	DuplicateRows int
}

// IsInvalidInnerCodeImport 判断错误是否需要用户修正上传文件。
func IsInvalidInnerCodeImport(err error) bool {
	return errors.Is(err, ErrInvalidInnerCodeImport)
}

// ValidateInnerCodeUpload 在落盘前限制 Excel 类型和大小。
func ValidateInnerCodeUpload(filename string, size int64, head []byte) error {
	if size <= 0 {
		return fmt.Errorf("文件是空的")
	}
	if size > MaxInnerCodeUploadBytes {
		return fmt.Errorf("文件超过 10MB 上限（当前约 %.1fMB）", float64(size)/1024/1024)
	}
	if !strings.EqualFold(filepath.Ext(filename), ".xlsx") {
		return fmt.Errorf("只允许 .xlsx 文件，收到的是 %q", filepath.Ext(filename))
	}
	if !bytes.HasPrefix(head, innerCodeXLSXMagic) {
		return fmt.Errorf("文件内容不像 xlsx，可能只是修改了扩展名")
	}
	return nil
}

// NormalizeInnerCodeSpecKey 把 Excel/顺运宝规格收敛为可比较的“颜色,尺码”。
// 它只做确定性清洗，解析不出来时保留清洗后的原文，不猜测含义。
func NormalizeInnerCodeSpecKey(value string) string {
	text := strings.TrimSpace(value)
	if text == "" {
		return ""
	}
	text = innerCodeBracketCN.ReplaceAllString(text, "")
	text = innerCodeParenthesesCN.ReplaceAllString(text, "")
	text = innerCodeParenthesesASCII.ReplaceAllString(text, "")
	text = innerCodeSuggestionTail.ReplaceAllString(text, "")
	text = strings.TrimSpace(innerCodeSpaces.ReplaceAllString(text, " "))
	color, size, found := strings.Cut(text, ",")
	if !found {
		return innerCodeSpaces.ReplaceAllString(text, "")
	}
	colorTokens := strings.Fields(color)
	if len(colorTokens) >= 2 && innerCodeStallToken.MatchString(colorTokens[0]) {
		color = strings.Join(colorTokens[1:], "")
	} else {
		color = innerCodeSpaces.ReplaceAllString(color, "")
	}
	size = innerCodeSpaces.ReplaceAllString(size, "")
	size = strings.ReplaceAll(size, "碼", "")
	size = innerCodeWeightTail.ReplaceAllString(size, "")
	if match := innerCodeSizeTail.FindStringSubmatch(size); len(match) == 2 {
		size = strings.ToUpper(match[1])
	}
	return color + "," + size
}

// ImportInnerCodeExcel 解析工作表并在一个事务中幂等写入业务表。
func ImportInnerCodeExcel(db *sql.DB, path, businessDate, actorUserID string) (*InnerCodeImportResult, error) {
	if _, err := time.Parse("2006-01-02", businessDate); err != nil {
		return nil, fmt.Errorf("%w：业务日期格式应为 YYYY-MM-DD", ErrInvalidInnerCodeImport)
	}
	if strings.TrimSpace(actorUserID) == "" {
		return nil, fmt.Errorf("导入账号不能为空")
	}
	book, err := excelize.OpenFile(path, excelize.Options{RawCellValue: true})
	if err != nil {
		return nil, fmt.Errorf("%w：打开 Excel 失败（%v）", ErrInvalidInnerCodeImport, err)
	}
	defer book.Close()

	result, rows, err := parseInnerCodeWorkbook(book, businessDate, actorUserID)
	if err != nil {
		return nil, fmt.Errorf("%w：%v", ErrInvalidInnerCodeImport, err)
	}
	tx, err := db.Begin()
	if err != nil {
		return nil, fmt.Errorf("开始档口入库码导入事务失败: %w", err)
	}
	defer tx.Rollback()
	now := model.NowISO()
	for _, row := range rows {
		outcome, err := repository.UpsertInnerCodeImportRow(tx, row, now)
		if err != nil {
			if errors.Is(err, repository.ErrInnerCodeUniqueConflict) {
				return nil, fmt.Errorf("%w：Excel 第 %d 行的入库码 %q 在该业务日期已属于另一条记录",
					ErrInvalidInnerCodeImport, row.SourceRow, row.InnerCode)
			}
			return nil, fmt.Errorf("导入 Excel 第 %d 行失败: %w", row.SourceRow, err)
		}
		if outcome == repository.InnerCodeImportCreated {
			result.CreatedCount++
		} else {
			result.UpdatedCount++
		}
	}
	if err := tx.Commit(); err != nil {
		return nil, fmt.Errorf("提交档口入库码导入事务失败: %w", err)
	}
	return result, nil
}

type innerCodeParsedRow struct {
	model.InnerCodeImportRow
	businessKey string
}

func parseInnerCodeWorkbook(book *excelize.File, businessDate, actorUserID string) (*InnerCodeImportResult, []model.InnerCodeImportRow, error) {
	found := false
	for _, name := range book.GetSheetList() {
		if name != innerCodeSheetName {
			continue
		}
		found = true
		rows, err := book.Rows(name)
		if err != nil {
			return nil, nil, fmt.Errorf("读取工作表 %q 失败: %w", name, err)
		}
		result, parsed, parseErr := parseInnerCodeRows(rows, businessDate, actorUserID)
		closeErr := rows.Close()
		if parseErr != nil {
			return nil, nil, parseErr
		}
		if closeErr != nil {
			return nil, nil, fmt.Errorf("关闭工作表 %q 失败: %w", name, closeErr)
		}
		return result, parsed, nil
	}
	if !found {
		return nil, nil, fmt.Errorf("Excel 中没有工作表 %q", innerCodeSheetName)
	}
	return nil, nil, fmt.Errorf("工作表 %q 无法读取", innerCodeSheetName)
}

func parseInnerCodeRows(rows *excelize.Rows, businessDate, actorUserID string) (*InnerCodeImportResult, []model.InnerCodeImportRow, error) {
	var headers map[string]int
	var specColumn int
	rowNumber := 0
	parsed := make([]innerCodeParsedRow, 0, 128)
	for rows.Next() {
		rowNumber++
		columns, err := rows.Columns()
		if err != nil {
			return nil, nil, fmt.Errorf("读取第 %d 行失败: %w", rowNumber, err)
		}
		if headers == nil {
			if rowNumber > 10 {
				break
			}
			candidate, candidateSpec := innerCodeHeaderMap(columns)
			if _, ok := candidate["内部档口入库码"]; ok {
				if _, ok = candidate["Shopee订单编号"]; ok && candidateSpec >= 0 {
					headers, specColumn = candidate, candidateSpec
				}
			}
			continue
		}
		orderNumber := innerCodeCell(columns, headers["Shopee订单编号"])
		innerCode := innerCodeCell(columns, headers["内部档口入库码"])
		if orderNumber == "" && innerCode == "" {
			continue
		}
		if len(parsed) >= MaxInnerCodeImportRows {
			return nil, nil, fmt.Errorf("非空数据超过 %d 条上限，请拆成多个文件导入", MaxInnerCodeImportRows)
		}
		if orderNumber == "" || innerCode == "" {
			return nil, nil, fmt.Errorf("第 %d 行缺少 Shopee订单编号或内部档口入库码", rowNumber)
		}
		specRaw := strings.ReplaceAll(innerCodeCell(columns, specColumn), "\r", " ")
		specRaw = strings.TrimSpace(strings.ReplaceAll(specRaw, "\n", " "))
		stall := innerCodeStall(columns, headers)
		shop := innerCodeNamedCell(columns, headers, "店铺名称")
		printSequence := 0
		if raw := innerCodeNamedCell(columns, headers, "标签打印序号"); raw != "" {
			if value, parseErr := strconv.Atoi(raw); parseErr == nil && value > 0 {
				printSequence = value
			}
		}
		if err := validateInnerCodeFields(rowNumber, orderNumber, shop, stall, specRaw, innerCode); err != nil {
			return nil, nil, err
		}
		specKey := NormalizeInnerCodeSpecKey(specRaw)
		key := strings.Join([]string{businessDate, orderNumber, stall, specKey}, "\x00")
		parsed = append(parsed, innerCodeParsedRow{InnerCodeImportRow: model.InnerCodeImportRow{
			BusinessDate: businessDate, SourceRow: rowNumber, PrintSequence: printSequence,
			OrderNumber: orderNumber, ShopName: shop, Stall: stall, SpecRaw: specRaw,
			SpecKey: specKey, InnerCode: innerCode, SourceDuplicateCount: 1,
			CreatedByUserID: actorUserID,
		}, businessKey: key})
	}
	if err := rows.Error(); err != nil {
		return nil, nil, fmt.Errorf("遍历工作表失败: %w", err)
	}
	if headers == nil {
		return nil, nil, fmt.Errorf("前 10 行未找到包含内部档口入库码、Shopee订单编号和规格列的表头")
	}
	if len(parsed) == 0 {
		return nil, nil, fmt.Errorf("工作表只有表头，没有可导入数据")
	}

	groups := make(map[string][]innerCodeParsedRow, len(parsed))
	codeKeys := make(map[string]string, len(parsed))
	for _, row := range parsed {
		groups[row.businessKey] = append(groups[row.businessKey], row)
		if oldKey, exists := codeKeys[row.InnerCode]; exists && oldKey != row.businessKey {
			return nil, nil, fmt.Errorf("同一业务日期的入库码 %q 对应多组订单/档口/规格", row.InnerCode)
		}
		codeKeys[row.InnerCode] = row.businessKey
	}
	result := &InnerCodeImportResult{TotalRows: len(parsed)}
	unique := make([]model.InnerCodeImportRow, 0, len(groups))
	seen := make(map[string]bool, len(groups))
	for _, original := range parsed {
		if seen[original.businessKey] {
			continue
		}
		seen[original.businessKey] = true
		group := groups[original.businessKey]
		for _, duplicate := range group[1:] {
			if duplicate.InnerCode != original.InnerCode {
				return nil, nil, fmt.Errorf("第 %d 行与第 %d 行业务键相同但入库码不同", original.SourceRow, duplicate.SourceRow)
			}
		}
		row := original.InnerCodeImportRow
		row.SourceDuplicateCount = len(group)
		unique = append(unique, row)
		result.DuplicateRows += len(group) - 1
	}
	return result, unique, nil
}

func innerCodeHeaderMap(columns []string) (map[string]int, int) {
	result := make(map[string]int, len(columns))
	specColumn := -1
	for index, raw := range columns {
		name := strings.TrimSpace(raw)
		result[name] = index
		if name == "清洗后规格" || (specColumn < 0 && strings.HasPrefix(name, "原始产品规格")) {
			specColumn = index
		}
	}
	return result, specColumn
}

func innerCodeStall(columns []string, headers map[string]int) string {
	if combined := innerCodeNamedCell(columns, headers, "档口及货号"); combined != "" {
		return combined
	}
	name := innerCodeNamedCell(columns, headers, "档口名称")
	article := innerCodeNamedCell(columns, headers, "档口货号")
	if name != "" && article != "" {
		return name + "#" + article
	}
	return name + article
}

func innerCodeNamedCell(columns []string, headers map[string]int, name string) string {
	index, ok := headers[name]
	if !ok {
		return ""
	}
	return innerCodeCell(columns, index)
}

func innerCodeCell(columns []string, index int) string {
	if index < 0 || index >= len(columns) {
		return ""
	}
	return strings.TrimSpace(columns[index])
}

func validateInnerCodeFields(row int, order, shop, stall, spec, code string) error {
	for _, field := range []struct {
		name, value string
		max         int
	}{
		{"Shopee订单编号", order, 64}, {"店铺名称", shop, 191}, {"档口及货号", stall, 191},
		{"规格", spec, 500}, {"内部档口入库码", code, 128},
	} {
		if utf8.RuneCountInString(field.value) > field.max {
			return fmt.Errorf("第 %d 行%s超过 %d 个字符", row, field.name, field.max)
		}
	}
	return nil
}