feat(database): add gearTxt field to parsed results and update related functions

2026-02-17 22:42:59 +08:00
parent 5dba3d9930
commit 8c4c4e77d7
13 changed files with 658 additions and 226 deletions
--- a/internal/model/database.go
+++ b/internal/model/database.go
@@ -6,59 +6,60 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"

 	_ "modernc.org/sqlite"
 )

-// Database 数据库管理器
+// Database manages the app database.
 type Database struct {
 	db *sql.DB
 }

-// NewDatabase 创建新的数据库连接
+// NewDatabase creates a new database connection.
 func NewDatabase() (*Database, error) {
 	dbPath := getDatabasePath()
 	log.Printf("[db] init: path=%s", dbPath)

-	// 确保目录存在
+	// Ensure directory exists.
 	dir := filepath.Dir(dbPath)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		log.Printf("[db] mkdir failed: dir=%s err=%v", dir, err)
-		return nil, fmt.Errorf("创建数据库目录失败: %w", err)
+		return nil, fmt.Errorf("create database dir failed: %w", err)
 	}

-	// 连接数据库
+	// Connect database.
 	db, err := sql.Open("sqlite", dbPath)
 	if err != nil {
 		log.Printf("[db] open failed: path=%s err=%v", dbPath, err)
-		return nil, fmt.Errorf("连接数据库失败: %w", err)
+		return nil, fmt.Errorf("open database failed: %w", err)
 	}

-	// 测试连接
+	// Test connection.
 	if err := db.Ping(); err != nil {
 		log.Printf("[db] ping failed: err=%v", err)
-		return nil, fmt.Errorf("数据库连接测试失败: %w", err)
+		return nil, fmt.Errorf("database ping failed: %w", err)
 	}

 	database := &Database{db: db}

-	// 初始化表结构
+	// Init tables.
 	if err := database.initTables(); err != nil {
 		log.Printf("[db] init tables failed: err=%v", err)
-		return nil, fmt.Errorf("初始化数据库表失败: %w", err)
+		return nil, fmt.Errorf("init tables failed: %w", err)
 	}

 	log.Printf("[db] init ok")
 	return database, nil
 }

-// Close 关闭数据库连接
+// Close closes the database connection.
 func (d *Database) Close() error {
 	return d.db.Close()
 }

-// getDatabasePath 获取数据库文件路径
+// getDatabasePath returns the database file path.
 func getDatabasePath() string {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
@@ -67,19 +68,18 @@ func getDatabasePath() string {
 	return filepath.Join(homeDir, ".equipment-analyzer", "equipment_analyzer.db")
 }

-// initTables 初始化数据库表结构
+// initTables creates tables if not exist.
 func (d *Database) initTables() error {
-	// 解析数据表 - 存储抓包解析后的装备和角色数据
 	parsedDataTable := `
 	CREATE TABLE IF NOT EXISTS parsed_data (
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		session_name TEXT NOT NULL,
 		items_json TEXT NOT NULL,
 		heroes_json TEXT NOT NULL,
+		geartxt TEXT NOT NULL DEFAULT '',
 		created_at INTEGER NOT NULL
 	);`

-	// 应用设置表
 	settingsTable := `
 	CREATE TABLE IF NOT EXISTS app_settings (
 		key TEXT PRIMARY KEY,
@@ -94,44 +94,59 @@ func (d *Database) initTables() error {

 	for _, table := range tables {
 		if _, err := d.db.Exec(table); err != nil {
-			return fmt.Errorf("创建表失败: %w", err)
+			return fmt.Errorf("create table failed: %w", err)
 		}
 	}

+	if err := d.ensureParsedDataColumns(); err != nil {
+		return err
+	}
+
 	return nil
 }

-// SaveParsedData 保存解析后的数据
-func (d *Database) SaveParsedData(sessionName string, itemsJSON, heroesJSON string) error {
-	stmt := `
-	INSERT INTO parsed_data (session_name, items_json, heroes_json, created_at)
-	VALUES (?, ?, ?, ?)`
+func (d *Database) ensureParsedDataColumns() error {
+	_, err := d.db.Exec("ALTER TABLE parsed_data ADD COLUMN geartxt TEXT NOT NULL DEFAULT ''")
+	if err != nil {
+		if strings.Contains(err.Error(), "duplicate column name") {
+			return nil
+		}
+		return fmt.Errorf("add geartxt column failed: %w", err)
+	}
+	return nil
+}

-	_, err := d.db.Exec(stmt, sessionName, itemsJSON, heroesJSON, time.Now().Unix())
+// SaveParsedData saves parsed items/heroes with raw gear txt.
+func (d *Database) SaveParsedData(sessionName string, itemsJSON, heroesJSON, gearTxt string) error {
+	stmt := `
+	INSERT INTO parsed_data (session_name, items_json, heroes_json, geartxt, created_at)
+	VALUES (?, ?, ?, ?, ?)`
+
+	_, err := d.db.Exec(stmt, sessionName, itemsJSON, heroesJSON, gearTxt, time.Now().Unix())
 	return err
 }

-// GetLatestParsedData 获取最新的解析数据
-func (d *Database) GetLatestParsedData() (string, string, error) {
+// GetLatestParsedData returns latest parsed data.
+func (d *Database) GetLatestParsedData() (string, string, string, error) {
 	stmt := `
-	SELECT items_json, heroes_json 
-	FROM parsed_data 
-	ORDER BY created_at DESC 
+	SELECT items_json, heroes_json, geartxt
+	FROM parsed_data
+	ORDER BY created_at DESC
 	LIMIT 1`

-	var itemsJSON, heroesJSON string
-	err := d.db.QueryRow(stmt).Scan(&itemsJSON, &heroesJSON)
+	var itemsJSON, heroesJSON, gearTxt string
+	err := d.db.QueryRow(stmt).Scan(&itemsJSON, &heroesJSON, &gearTxt)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return "", "", nil
+			return "", "", "", nil
 		}
-		return "", "", err
+		return "", "", "", err
 	}

-	return itemsJSON, heroesJSON, nil
+	return itemsJSON, heroesJSON, gearTxt, nil
 }

-// GetParsedSessions 获取所有解析会话
+// GetParsedSessions returns all parsed sessions.
 func (d *Database) GetParsedSessions() ([]ParsedSession, error) {
 	stmt := `
 	SELECT id, session_name, created_at
@@ -155,26 +170,26 @@ func (d *Database) GetParsedSessions() ([]ParsedSession, error) {
 	return sessions, nil
 }

-// GetParsedDataByID 获取指定会话的数据
-func (d *Database) GetParsedDataByID(id int64) (string, string, error) {
+// GetParsedDataByID returns parsed data for a session.
+func (d *Database) GetParsedDataByID(id int64) (string, string, string, error) {
 	stmt := `
-	SELECT items_json, heroes_json
+	SELECT items_json, heroes_json, geartxt
 	FROM parsed_data
 	WHERE id = ?
 	LIMIT 1`

-	var itemsJSON, heroesJSON string
-	err := d.db.QueryRow(stmt, id).Scan(&itemsJSON, &heroesJSON)
+	var itemsJSON, heroesJSON, gearTxt string
+	err := d.db.QueryRow(stmt, id).Scan(&itemsJSON, &heroesJSON, &gearTxt)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return "", "", nil
+			return "", "", "", nil
 		}
-		return "", "", err
+		return "", "", "", err
 	}
-	return itemsJSON, heroesJSON, nil
+	return itemsJSON, heroesJSON, gearTxt, nil
 }

-// UpdateParsedSessionName 更新解析会话名称
+// UpdateParsedSessionName updates session name.
 func (d *Database) UpdateParsedSessionName(id int64, name string) error {
 	stmt := `
 	UPDATE parsed_data
@@ -184,7 +199,7 @@ func (d *Database) UpdateParsedSessionName(id int64, name string) error {
 	return err
 }

-// DeleteParsedSession 删除解析会话
+// DeleteParsedSession deletes a parsed session.
 func (d *Database) DeleteParsedSession(id int64) error {
 	stmt := `
 	DELETE FROM parsed_data
@@ -193,14 +208,14 @@ func (d *Database) DeleteParsedSession(id int64) error {
 	return err
 }

-// SaveSetting 保存应用设置
+// SaveSetting saves app setting.
 func (d *Database) SaveSetting(key, value string) error {
 	stmt := "INSERT OR REPLACE INTO app_settings (key, value, updated_at) VALUES (?, ?, ?)"
 	_, err := d.db.Exec(stmt, key, value, time.Now().Unix())
 	return err
 }

-// GetSetting 获取应用设置
+// GetSetting returns app setting.
 func (d *Database) GetSetting(key string) (string, error) {
 	stmt := "SELECT value FROM app_settings WHERE key = ?"
 	var value string
@@ -211,7 +226,7 @@ func (d *Database) GetSetting(key string) (string, error) {
 	return value, nil
 }

-// GetAllSettings 获取所有设置
+// GetAllSettings returns all settings.
 func (d *Database) GetAllSettings() (map[string]string, error) {
 	stmt := "SELECT key, value FROM app_settings"
 	rows, err := d.db.Query(stmt)
--- a/internal/model/packet.go
+++ b/internal/model/packet.go
@@ -32,8 +32,9 @@ type CaptureStatus struct {

 // ParsedResult 解析结果
 type ParsedResult struct {
-	Items  []interface{} `json:"items"`
-	Heroes []interface{} `json:"heroes"`
+	Items   []interface{} `json:"items"`
+	Heroes  []interface{} `json:"heroes"`
+	GearTxt string        `json:"geartxt"`
 }

 // ParsedSession 解析数据会话信息
--- a/internal/service/database_service.go
+++ b/internal/service/database_service.go
@@ -22,8 +22,8 @@ func NewDatabaseService(db *model.Database, logger *utils.Logger) *DatabaseServi
 }

 // SaveParsedDataToDatabase 保存解析后的数据到数据库
-func (s *DatabaseService) SaveParsedDataToDatabase(sessionName string, itemsJSON, heroesJSON string) error {
-	err := s.db.SaveParsedData(sessionName, itemsJSON, heroesJSON)
+func (s *DatabaseService) SaveParsedDataToDatabase(sessionName string, itemsJSON, heroesJSON, gearTxt string) error {
+	err := s.db.SaveParsedData(sessionName, itemsJSON, heroesJSON, gearTxt)
 	if err != nil {
 		s.logger.Error("保存解析数据到数据库失败", "error", err, "session_name", sessionName)
 		return fmt.Errorf("保存解析数据失败: %w", err)
@@ -34,15 +34,15 @@ func (s *DatabaseService) SaveParsedDataToDatabase(sessionName string, itemsJSON
 }

 // GetLatestParsedDataFromDatabase 从数据库获取最新的解析数据
-func (s *DatabaseService) GetLatestParsedDataFromDatabase() (string, string, error) {
-	itemsJSON, heroesJSON, err := s.db.GetLatestParsedData()
+func (s *DatabaseService) GetLatestParsedDataFromDatabase() (string, string, string, error) {
+	itemsJSON, heroesJSON, gearTxt, err := s.db.GetLatestParsedData()
 	if err != nil {
 		s.logger.Error("从数据库获取最新解析数据失败", "error", err)
-		return "", "", fmt.Errorf("获取解析数据失败: %w", err)
+		return "", "", "", fmt.Errorf("获取解析数据失败: %w", err)
 	}

 	s.logger.Info("最新解析数据获取成功")
-	return itemsJSON, heroesJSON, nil
+	return itemsJSON, heroesJSON, gearTxt, nil
 }

 // GetParsedSessions 从数据库获取所有解析会话
@@ -56,13 +56,13 @@ func (s *DatabaseService) GetParsedSessions() ([]model.ParsedSession, error) {
 }

 // GetParsedDataByID 从数据库获取指定会话数据
-func (s *DatabaseService) GetParsedDataByID(id int64) (string, string, error) {
-	itemsJSON, heroesJSON, err := s.db.GetParsedDataByID(id)
+func (s *DatabaseService) GetParsedDataByID(id int64) (string, string, string, error) {
+	itemsJSON, heroesJSON, gearTxt, err := s.db.GetParsedDataByID(id)
 	if err != nil {
 		s.logger.Error("从数据库获取解析数据失败", "error", err, "id", id)
-		return "", "", fmt.Errorf("获取解析数据失败: %w", err)
+		return "", "", "", fmt.Errorf("获取解析数据失败: %w", err)
 	}
-	return itemsJSON, heroesJSON, nil
+	return itemsJSON, heroesJSON, gearTxt, nil
 }

 // UpdateParsedSessionName 更新解析会话名称
--- a/internal/service/main_service.go
+++ b/internal/service/main_service.go
@@ -365,7 +365,7 @@ func (a *App) StopAndParseCapture() (*model.ParsedResult, error) {
 		}

 		sessionName := fmt.Sprintf("capture_%d", time.Now().Unix())
-		if err := a.databaseService.SaveParsedDataToDatabase(sessionName, itemsJSON, heroesJSON); err != nil {
+		if err := a.databaseService.SaveParsedDataToDatabase(sessionName, itemsJSON, heroesJSON, result.GearTxt); err != nil {
 			a.logger.Error("save parsed data failed", "error", err)
 		} else {
 			a.logger.Info("parsed data saved", "session_name", sessionName)
@@ -376,11 +376,42 @@ func (a *App) StopAndParseCapture() (*model.ParsedResult, error) {
 }

 // SaveParsedDataToDatabase saves parsed data.
-func (a *App) SaveParsedDataToDatabase(sessionName string, itemsJSON, heroesJSON string) error {
+func (a *App) SaveParsedDataToDatabase(sessionName string, itemsJSON, heroesJSON, gearTxt string) error {
 	if a.databaseService == nil {
 		return fmt.Errorf("database service not initialized")
 	}
-	return a.databaseService.SaveParsedDataToDatabase(sessionName, itemsJSON, heroesJSON)
+	return a.databaseService.SaveParsedDataToDatabase(sessionName, itemsJSON, heroesJSON, gearTxt)
+}
+
+// ParseAndSaveRawJson parses raw gear json and saves to database.
+func (a *App) ParseAndSaveRawJson(sessionName string, rawJson string) (*model.ParsedResult, error) {
+	if a.databaseService == nil {
+		return nil, fmt.Errorf("database service not initialized")
+	}
+	if sessionName == "" {
+		return nil, fmt.Errorf("session name cannot be empty")
+	}
+	result, err := a.parserService.ReadRawJsonFile(rawJson)
+	if err != nil {
+		return nil, err
+	}
+
+	itemsJSON := "[]"
+	if result.Items != nil {
+		if jsonData, err := json.Marshal(result.Items); err == nil {
+			itemsJSON = string(jsonData)
+		}
+	}
+	heroesJSON := "[]"
+	if result.Heroes != nil {
+		if jsonData, err := json.Marshal(result.Heroes); err == nil {
+			heroesJSON = string(jsonData)
+		}
+	}
+	if err := a.databaseService.SaveParsedDataToDatabase(sessionName, itemsJSON, heroesJSON, result.GearTxt); err != nil {
+		a.logger.Error("save parsed data failed", "error", err, "session_name", sessionName)
+	}
+	return result, nil
 }

 // GetLatestParsedDataFromDatabase returns latest parsed data from database.
@@ -389,7 +420,7 @@ func (a *App) GetLatestParsedDataFromDatabase() (*model.ParsedResult, error) {
 		return nil, fmt.Errorf("database service not initialized")
 	}

-	itemsJSON, heroesJSON, err := a.databaseService.GetLatestParsedDataFromDatabase()
+	itemsJSON, heroesJSON, gearTxt, err := a.databaseService.GetLatestParsedDataFromDatabase()
 	if err != nil {
 		return nil, err
 	}
@@ -412,6 +443,7 @@ func (a *App) GetLatestParsedDataFromDatabase() (*model.ParsedResult, error) {
 	return &model.ParsedResult{
 		Items:  items,
 		Heroes: heroes,
+		GearTxt: gearTxt,
 	}, nil
 }

@@ -428,7 +460,7 @@ func (a *App) GetParsedDataByID(id int64) (*model.ParsedResult, error) {
 	if a.databaseService == nil {
 		return nil, fmt.Errorf("database service not initialized")
 	}
-	itemsJSON, heroesJSON, err := a.databaseService.GetParsedDataByID(id)
+	itemsJSON, heroesJSON, gearTxt, err := a.databaseService.GetParsedDataByID(id)
 	if err != nil {
 		return nil, err
 	}
@@ -450,6 +482,7 @@ func (a *App) GetParsedDataByID(id int64) (*model.ParsedResult, error) {
 	return &model.ParsedResult{
 		Items:  items,
 		Heroes: heroes,
+		GearTxt: gearTxt,
 	}, nil
 }

--- a/internal/service/parser_service.go
+++ b/internal/service/parser_service.go
@@ -26,6 +26,7 @@ type ParserService struct {
 	heroBase  map[string]heroBaseStats
 	heroOnce  sync.Once
 	heroErr   error
+	fallbackMainStatCount int
 }

 func NewParserService(cfg *config.Config, logger *utils.Logger) *ParserService {
@@ -37,24 +38,43 @@ func NewParserService(cfg *config.Config, logger *utils.Logger) *ParserService {
 	}
 }

+
+func (ps *ParserService) writeParseSnapshot(kind string, data []byte) {
+	if len(data) == 0 {
+		return
+	}
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return
+	}
+	dir := filepath.Join(homeDir, ".equipment-analyzer", "remote_parse_snapshots")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return
+	}
+	stamp := time.Now().Format("20060102_150405.000")
+	filename := filepath.Join(dir, stamp+"_"+kind+".json")
+	_ = os.WriteFile(filename, data, 0644)
+}
+
 // ParseHexData 解析十六进制数据
 func (ps *ParserService) ParseHexData(hexDataList []string) (*model.ParsedResult, string, error) {
 	if len(hexDataList) == 0 {
-		ps.logger.Warn("没有数据需要解析")
+		ps.logger.Warn("no data to parse")
 		return &model.ParsedResult{
 			Items:  make([]interface{}, 0),
 			Heroes: make([]interface{}, 0),
 		}, "", nil
 	}

-	ps.logger.Info("开始远程解析数据", "count", len(hexDataList))
+	ps.logger.Info("remote parse start", "count", len(hexDataList))

 	url := "https://krivpfvxi0.execute-api.us-west-2.amazonaws.com/dev/getItems"
 	reqBody := map[string]interface{}{
 		"data": hexDataList,
 	}
 	jsonBytes, _ := json.Marshal(reqBody)
-	client := &http.Client{Timeout: 15 * time.Second}
+	ps.writeParseSnapshot("request", jsonBytes)
+	client := &http.Client{Timeout: 60 * time.Second}
 	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBytes))
 	if err == nil {
 		req.Header.Set("Content-Type", "application/json")
@@ -62,23 +82,21 @@ func (ps *ParserService) ParseHexData(hexDataList []string) (*model.ParsedResult
 		if err == nil && resp.StatusCode == 200 {
 			defer resp.Body.Close()
 			body, _ := ioutil.ReadAll(resp.Body)
+			ps.writeParseSnapshot("response", body)

-			// 新校验逻辑：校验data和units字段
 			var raw map[string]interface{}
 			if err := json.Unmarshal(body, &raw); err != nil {
-				ps.logger.Error("远程json解析失败", "error", err)
-				return nil, "", fmt.Errorf("远程json解析失败: %v", err)
+				ps.logger.Error("remote json unmarshal failed", "error", err)
+				return nil, "", fmt.Errorf("remote json unmarshal failed: %v", err)
 			}

-			// 校验data字段
 			dataArr, dataOk := raw["data"].([]interface{})
 			if !dataOk || len(dataArr) == 0 {
-				ps.logger.Error("远程json校验失败，data字段缺失或为空")
-				return nil, "", fmt.Errorf("远程json校验失败，data字段缺失或为空")
+				ps.logger.Error("remote json validate failed: data missing or empty")
+				return nil, "", fmt.Errorf("remote json validate failed: data missing or empty")
 			}

-			// 校验通过，直接解析数据
-			ps.logger.Info("远程原始数据校验通过，开始解析")
+			ps.logger.Info("remote json validate ok, start parse")
 			parsedResult, err := ps.ReadRawJsonFile(string(body))
 			if err != nil {
 				return nil, "", err
@@ -86,15 +104,15 @@ func (ps *ParserService) ParseHexData(hexDataList []string) (*model.ParsedResult

 			return parsedResult, "", nil
 		} else if err != nil {
-			ps.logger.Error("远程解析请求失败", "error", err)
-			return nil, "", fmt.Errorf("远程解析请求失败: %v", err)
+			ps.logger.Error("remote parse request failed", "error", err)
+			return nil, "", fmt.Errorf("remote parse request failed: %v", err)
 		} else {
-			ps.logger.Error("远程解析响应码异常", "status", resp.StatusCode)
-			return nil, "", fmt.Errorf("远程解析响应码异常: %d", resp.StatusCode)
+			ps.logger.Error("remote parse http status", "status", resp.StatusCode)
+			return nil, "", fmt.Errorf("remote parse http status %d", resp.StatusCode)
 		}
 	} else {
-		ps.logger.Error("远程解析请求构建失败", "error", err)
-		return nil, "", fmt.Errorf("远程解析请求构建失败: %v", err)
+		ps.logger.Error("remote parse request build failed", "error", err)
+		return nil, "", fmt.Errorf("remote parse request build failed: %v", err)
 	}
 }

@@ -106,7 +124,62 @@ func (ps *ParserService) ReadRawJsonFile(rawJson string) (*model.ParsedResult, e
 		return nil, err
 	}

-	// 提取装备和英雄数据
+
+	// If input is already parsed (gear.txt export), use items/heroes directly.
+	if itemsRaw, ok := rawData["items"].([]interface{}); ok {
+		heroesRaw, _ := rawData["heroes"].([]interface{})
+		parsedItems := ps.normalizeParsedItems(itemsRaw)
+		result := &model.ParsedResult{
+			Items:   parsedItems,
+			Heroes:  heroesRaw,
+			GearTxt: rawJson,
+		}
+		return result, nil
+	}
+
+	// If input is a mixed "data" array (remote parse response), split items/heroes.
+	if dataRaw, ok := rawData["data"].([]interface{}); ok && len(dataRaw) > 0 {
+		dataItems, dataHeroes := ps.splitDataArray(dataRaw)
+		if len(dataItems) > 0 || len(dataHeroes) > 0 {
+			ps.logger.Info("raw json format: mixed data array", "items", len(dataItems), "heroes", len(dataHeroes))
+			// If heroes are not present in data array, fall back to units.
+			var rawUnits []interface{}
+			if unitsRaw, ok := rawData["units"].([]interface{}); ok && len(unitsRaw) > 0 {
+				maxLen := 0
+				for _, u := range unitsRaw {
+					if arr, ok := u.([]interface{}); ok && len(arr) > maxLen {
+						maxLen = len(arr)
+						rawUnits = arr
+					}
+				}
+			}
+
+			parsedHeroes := dataHeroes
+			if len(rawUnits) > 0 {
+				parsedHeroes = rawUnits
+			}
+
+			ps.fallbackMainStatCount = 0
+			convertedItems := ps.convertItemsAllWithLog(dataItems)
+			ps.logger.Info("main stat fallback count", "count", ps.fallbackMainStatCount)
+			convertedHeroes := ps.convertUnits(parsedHeroes)
+
+			result := &model.ParsedResult{
+				Items:  make([]interface{}, len(convertedItems)),
+				Heroes: make([]interface{}, len(convertedHeroes)),
+			}
+			for i, v := range convertedItems {
+				result.Items[i] = v
+			}
+			for i, v := range convertedHeroes {
+				result.Heroes[i] = v
+			}
+			result.GearTxt = rawJson
+			return result, nil
+		}
+	}
+
+	// 提取装备和英雄数?
 	equips, _ := rawData["data"].([]interface{})
 	// 修正：units 取最大长度的那组
 	var rawUnits []interface{}
@@ -131,8 +204,10 @@ func (ps *ParserService) ReadRawJsonFile(rawJson string) (*model.ParsedResult, e
 	}

 	// 转换装备数据
+	ps.fallbackMainStatCount = 0
 	convertedItems := ps.convertItemsAllWithLog(validEquips)
-	// 转换英雄数据（只对最大组）
+	ps.logger.Info("main stat fallback count", "count", ps.fallbackMainStatCount)
+	// 转换英雄数据（只对最大组?
 	convertedHeroes := ps.convertUnits(rawUnits)

 	result := &model.ParsedResult{
@@ -145,10 +220,115 @@ func (ps *ParserService) ReadRawJsonFile(rawJson string) (*model.ParsedResult, e
 	for i, v := range convertedHeroes {
 		result.Heroes[i] = v
 	}
+	result.GearTxt = rawJson

 	return result, nil
 }

+
+func (ps *ParserService) isGearRecord(itemMap map[string]interface{}) bool {
+	// Require set field if present in this raw format.
+	if f, ok := itemMap["f"].(string); ok && f != "" {
+		return true
+	}
+	// Allow already-normalized gear fields from other sources.
+	if _, ok := itemMap["set"]; ok {
+		return true
+	}
+	if _, ok := itemMap["gear"]; ok {
+		return true
+	}
+	if _, ok := itemMap["type"]; ok {
+		return true
+	}
+	if _, ok := itemMap["mainStatType"]; ok {
+		return true
+	}
+	// Otherwise treat as non-gear to avoid including material-like records.
+	return false
+}
+
+func (ps *ParserService) isHeroRecord(itemMap map[string]interface{}) bool {
+	if name, ok := itemMap["name"].(string); ok && name != "" && name != "Unknown" {
+		return true
+	}
+	if code, ok := itemMap["code"].(string); ok && strings.HasPrefix(code, "c") {
+		return true
+	}
+	// heroes commonly have opt/exp fields
+	if _, ok := itemMap["opt"]; ok {
+		return true
+	}
+	if _, ok := itemMap["exp"]; ok {
+		return true
+	}
+	return false
+}
+
+
+func (ps *ParserService) splitDataArray(data []interface{}) (items []interface{}, heroes []interface{}) {
+	for _, entry := range data {
+		itemMap, ok := entry.(map[string]interface{})
+		if !ok || itemMap == nil {
+			continue
+		}
+		if ps.isGearRecord(itemMap) {
+			items = append(items, entry)
+			continue
+		}
+		if ps.isHeroRecord(itemMap) {
+			heroes = append(heroes, entry)
+			continue
+		}
+	}
+	return items, heroes
+}
+
+
+func (ps *ParserService) normalizeParsedItems(items []interface{}) []interface{} {
+	for i, item := range items {
+		itemMap, ok := item.(map[string]interface{})
+		if !ok || itemMap == nil {
+			continue
+		}
+		if _, exists := itemMap["main"]; exists {
+			continue
+		}
+		op, opExists := itemMap["op"].([]interface{})
+		if !opExists || len(op) == 0 {
+			continue
+		}
+		mainOp, ok := op[0].([]interface{})
+		if !ok || len(mainOp) < 2 {
+			continue
+		}
+		mainOpType, _ := mainOp[0].(string)
+		mainOpValue, _ := mainOp[1].(float64)
+		if mainOpType == "" {
+			continue
+		}
+		mainType := statByIngameStat[mainOpType]
+		if mainType == "" {
+			continue
+		}
+		var mainValue float64
+		if ps.isFlat(mainOpType) {
+			mainValue = mainOpValue
+		} else {
+			mainValue = ps.round10ths(mainOpValue * 100)
+		}
+		if mainValue == 0 || mainValue != mainValue {
+			mainValue = 0
+		}
+		itemMap["main"] = map[string]interface{}{
+			"type":  mainType,
+			"value": mainValue,
+		}
+		items[i] = itemMap
+	}
+	return items
+}
+
 // convertItems 转换装备数据
 func (ps *ParserService) convertItems(rawItems []interface{}) []map[string]interface{} {
 	var convertedItems []map[string]interface{}
@@ -197,10 +377,10 @@ func (ps *ParserService) convertSingleItem(item map[string]interface{}) map[stri
 	// 转换增强
 	ps.convertEnhance(converted)

-	// 转换主属性
+	// 转换主属?
 	ps.convertMainStat(converted)

-	// 转换副属性
+	// 转换副属?
 	ps.convertSubStats(converted)

 	// 转换ID
@@ -227,7 +407,7 @@ func (ps *ParserService) convertUnits(rawUnits []interface{}) []map[string]inter
 						convertedUnit[key] = value
 					}

-					// 转换星星和觉醒
+					// 转换星星和觉?
 					if g, exists := unitMap["g"]; exists {
 						convertedUnit["stars"] = g
 					}
@@ -335,6 +515,7 @@ func (ps *ParserService) convertEnhance(item map[string]interface{}) {
 func (ps *ParserService) convertMainStat(item map[string]interface{}) {
 	op, opExists := item["op"].([]interface{})
 	mainStatValue, mainStatExists := item["mainStatValue"].(float64)
+	fallbackUsed := false

 	if opExists && len(op) > 0 && mainStatExists {
 		if mainOp, ok := op[0].([]interface{}); ok && len(mainOp) > 0 {
@@ -359,6 +540,39 @@ func (ps *ParserService) convertMainStat(item map[string]interface{}) {
 			}
 		}
 	}
+
+	// Fallback: if main is missing, derive from op[0] value directly.
+	if _, exists := item["main"]; !exists {
+		if opExists && len(op) > 0 {
+			if mainOp, ok := op[0].([]interface{}); ok && len(mainOp) >= 2 {
+				mainOpType, _ := mainOp[0].(string)
+				mainOpValue, _ := mainOp[1].(float64)
+				if mainOpType != "" {
+					mainType := statByIngameStat[mainOpType]
+					if mainType != "" {
+						var mainValue float64
+						if ps.isFlat(mainOpType) {
+							mainValue = mainOpValue
+						} else {
+							mainValue = ps.round10ths(mainOpValue * 100)
+						}
+						if mainValue == 0 || mainValue != mainValue {
+							mainValue = 0
+						}
+						item["main"] = map[string]interface{}{
+							"type":  mainType,
+							"value": mainValue,
+						}
+						fallbackUsed = true
+					}
+				}
+			}
+		}
+	}
+
+	if fallbackUsed {
+		ps.fallbackMainStatCount++
+	}
 }

 func (ps *ParserService) convertSubStats(item map[string]interface{}) {
@@ -371,7 +585,7 @@ func (ps *ParserService) convertSubStats(item map[string]interface{}) {

 	statAcc := make(map[string]map[string]interface{})

-	// 处理副属性 (从索引1开始)
+	// 处理副属?(从索?开?
 	for i := 1; i < len(op); i++ {
 		if opItem, ok := op[i].([]interface{}); ok && len(opItem) >= 2 {
 			opType, _ := opItem[0].(string)
@@ -417,7 +631,7 @@ func (ps *ParserService) convertSubStats(item map[string]interface{}) {
 		}
 	}

-	// 转换为最终格式
+	// 转换为最终格?
 	var substats []interface{}
 	for statType, statData := range statAcc {
 		substat := map[string]interface{}{
@@ -765,3 +979,4 @@ func (ps *ParserService) applyHeroBase(unit map[string]interface{}, base heroBas
 		unit["res"] = base.Res
 	}
 }
+