dat

type ArrayReader struct {
	// contains filtered or unexported fields
}

type BinaryReader struct {
	// contains filtered or unexported fields
}

type ColumnReference struct {
	Table  string  `json:"table"`            // Referenced table name
	Column *string `json:"column,omitempty"` // Referenced column name (optional)
}

type CommunitySchema struct {
	SchemaMetadata
	Tables       []TableSchema       `json:"tables"`       // Table definitions
	Enumerations []SchemaEnumeration `json:"enumerations"` // Enumeration definitions
}

type DATParser struct {
	// contains filtered or unexported fields
}

type DatFile struct {
	// RowCount is the number of rows in the DAT file (first 4 bytes)
	RowCount int

	// RowLength is the fixed size of each row in bytes
	RowLength int

	// FixedData contains the fixed-size row data section
	FixedData []byte

	// DynamicData contains the variable-length data section (strings, arrays)
	// Starts after the boundary marker (\xbb\xbb\xbb\xbb\xbb\xbb\xbb\xbb)
	DynamicData []byte
}

type DataValidator struct {
	// contains filtered or unexported fields
}

type FieldBounds struct {
	Offset    int
	EndOffset int
	FieldType FieldType
	IsArray   bool
}

type FieldType string

type ParseMetadata struct {
	FixedDataSize   int `json:"fixedDataSize"`   // Size of fixed data section
	DynamicDataSize int `json:"dynamicDataSize"` // Size of dynamic data section
	TotalFileSize   int `json:"totalFileSize"`   // Total DAT file size
	MaxFieldsParsed int `json:"maxFieldsParsed"` // Maximum number of fields parsed in any row (for partial schema)
}

type ParsedRow struct {
	Index        int                    `json:"index"`        // Row index (0-based)
	Fields       map[string]interface{} `json:"fields"`       // Field name to parsed value mapping
	FieldsParsed int                    `json:"fieldsParsed"` // Number of fields successfully parsed (useful for partial schema)
}

type ParsedTable struct {
	Schema   *TableSchema   `json:"schema"`   // Original table schema
	RowCount int            `json:"rowCount"` // Number of rows parsed
	Rows     []ParsedRow    `json:"rows"`     // All parsed row data
	Metadata *ParseMetadata `json:"metadata"` // Parsing metadata
}

type Parser interface {
	// ParseDATFile parses a DAT file from the given reader using the provided schema
	ParseDATFile(ctx context.Context, r io.Reader, schema *TableSchema) (*ParsedTable, error)

	// ParseDATFileWithFilename parses a DAT file with width detection based on filename extension
	ParseDATFileWithFilename(ctx context.Context, r io.Reader, filename string, schema *TableSchema) (*ParsedTable, error)

	// ReadField reads a single field value from the DAT data
	ReadField(data []byte, column *TableColumn, dynamicData []byte) (interface{}, error)

	// ReadString reads a UTF-16 string from the dynamic data section
	ReadString(dynamicData []byte, offset uint64) (string, error)

	// ReadArray reads an array of values from the dynamic data section
	ReadArray(dynamicData []byte, offset uint64, count uint64, elementType FieldType) (interface{}, error)
}

type ParserOptions struct {
	// StrictMode enables strict validation of DAT file format
	StrictMode bool

	// ValidateReferences checks that foreign key references point to valid rows
	ValidateReferences bool

	// MaxStringLength limits the maximum length of strings to prevent memory issues
	MaxStringLength int

	// MaxArrayCount limits the maximum number of array elements
	MaxArrayCount int

	// MaxJunctionTableArrayCount limits the maximum array size for junction table creation
	// This is separate from MaxArrayCount to allow different limits for different purposes
	MaxJunctionTableArrayCount int

	// ArraySizeWarningThreshold sets the threshold for logging warnings about large arrays
	ArraySizeWarningThreshold int
}

type ParserWidth int

type SchemaEnumeration struct {
	ValidFor    ValidFor  `json:"validFor"`    // Game version compatibility
	Name        string    `json:"name"`        // Enumeration name
	Indexing    int       `json:"indexing"`    // 0 or 1 based indexing
	Enumerators []*string `json:"enumerators"` // Enumeration values (nullable)
}

type SchemaManager struct {
	// contains filtered or unexported fields
}

type SchemaMetadata struct {
	Version   int `json:"version"`   // Schema version number
	CreatedAt int `json:"createdAt"` // Unix timestamp when schema was created
}

type StringReader struct {
	// contains filtered or unexported fields
}

type TableColumn struct {
	Name        *string          `json:"name"`
	Description *string          `json:"description"`
	Array       bool             `json:"array"`
	Type        FieldType        `json:"type"`
	Unique      bool             `json:"unique"`
	Localized   bool             `json:"localized"`
	Until       *string          `json:"until"`      // Version when this column was removed
	References  *ColumnReference `json:"references"` // Foreign key reference
	File        *string          `json:"file"`       // File extension for asset files
	Files       []string         `json:"files"`      // Multiple file extensions
	Interval    bool             `json:"interval"`   // Whether this is an interval field
}

type TableSchema struct {
	ValidFor ValidFor      `json:"validFor"` // Game version compatibility
	Name     string        `json:"name"`     // Table name (matches DAT filename)
	Columns  []TableColumn `json:"columns"`  // Column definitions
	Tags     []string      `json:"tags"`     // Metadata tags
}

type ValidFor int

type ValidationOptions struct {
	// MaxStringLength is the maximum allowed string length
	MaxStringLength int

	// MaxArrayCount is the maximum allowed array element count
	MaxArrayCount int

	// ValidateStringOffsets checks that string offsets are within bounds
	ValidateStringOffsets bool

	// ValidateArrayOffsets checks that array offsets are within bounds
	ValidateArrayOffsets bool
}