relspecgo/pkg/readers/bun/reader.go

package bun

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"strings"

	"git.warky.dev/wdevs/relspecgo/pkg/models"
	"git.warky.dev/wdevs/relspecgo/pkg/readers"
)

// Reader implements the readers.Reader interface for Bun Go model files
type Reader struct {
	options *readers.ReaderOptions
}

// NewReader creates a new Bun reader with the given options
func NewReader(options *readers.ReaderOptions) *Reader {
	return &Reader{
		options: options,
	}
}

// ReadDatabase reads Bun Go model files and returns a Database model
func (r *Reader) ReadDatabase() (*models.Database, error) {
	if r.options.FilePath == "" {
		return nil, fmt.Errorf("file path is required for Bun reader")
	}

	// Check if path is a directory or file
	info, err := os.Stat(r.options.FilePath)
	if err != nil {
		return nil, fmt.Errorf("failed to stat path: %w", err)
	}

	var files []string
	if info.IsDir() {
		// Read all .go files in directory
		entries, err := os.ReadDir(r.options.FilePath)
		if err != nil {
			return nil, fmt.Errorf("failed to read directory: %w", err)
		}
		for _, entry := range entries {
			if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") && !strings.HasSuffix(entry.Name(), "_test.go") {
				files = append(files, filepath.Join(r.options.FilePath, entry.Name()))
			}
		}
	} else {
		files = append(files, r.options.FilePath)
	}

	if len(files) == 0 {
		return nil, fmt.Errorf("no Go files found")
	}

	// Parse all files and collect tables
	db := models.InitDatabase("database")
	schemaMap := make(map[string]*models.Schema)

	for _, file := range files {
		tables, err := r.parseFile(file)
		if err != nil {
			return nil, fmt.Errorf("failed to parse file %s: %w", file, err)
		}

		for _, table := range tables {
			// Get or create schema
			schema, ok := schemaMap[table.Schema]
			if !ok {
				schema = models.InitSchema(table.Schema)
				schemaMap[table.Schema] = schema
			}
			schema.Tables = append(schema.Tables, table)
		}
	}

	// Convert schema map to slice
	for _, schema := range schemaMap {
		db.Schemas = append(db.Schemas, schema)
	}

	return db, nil
}

// ReadSchema reads Bun Go model files and returns a Schema model
func (r *Reader) ReadSchema() (*models.Schema, error) {
	db, err := r.ReadDatabase()
	if err != nil {
		return nil, err
	}

	if len(db.Schemas) == 0 {
		return nil, fmt.Errorf("no schemas found")
	}

	return db.Schemas[0], nil
}

// ReadTable reads a Bun Go model file and returns a Table model
func (r *Reader) ReadTable() (*models.Table, error) {
	schema, err := r.ReadSchema()
	if err != nil {
		return nil, err
	}

	if len(schema.Tables) == 0 {
		return nil, fmt.Errorf("no tables found")
	}

	return schema.Tables[0], nil
}

// parseFile parses a single Go file and extracts table models
func (r *Reader) parseFile(filename string) ([]*models.Table, error) {
	fset := token.NewFileSet()
	node, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
	if err != nil {
		return nil, fmt.Errorf("failed to parse Go file: %w", err)
	}

	var tables []*models.Table
	structMap := make(map[string]*models.Table)

	// First pass: collect struct definitions
	for _, decl := range node.Decls {
		genDecl, ok := decl.(*ast.GenDecl)
		if !ok || genDecl.Tok != token.TYPE {
			continue
		}

		for _, spec := range genDecl.Specs {
			typeSpec, ok := spec.(*ast.TypeSpec)
			if !ok {
				continue
			}

			structType, ok := typeSpec.Type.(*ast.StructType)
			if !ok {
				continue
			}

			// Check if this struct has bun tags (indicates it's a model)
			if r.hasModelFields(structType) {
				table := r.parseStruct(typeSpec.Name.Name, structType)
				if table != nil {
					structMap[typeSpec.Name.Name] = table
					tables = append(tables, table)
				}
			}
		}
	}

	// Second pass: find TableName() methods (for redundancy/verification)
	for _, decl := range node.Decls {
		funcDecl, ok := decl.(*ast.FuncDecl)
		if !ok || funcDecl.Name.Name != "TableName" {
			continue
		}

		// Get receiver type
		if funcDecl.Recv == nil || len(funcDecl.Recv.List) == 0 {
			continue
		}

		receiverType := r.getReceiverType(funcDecl.Recv.List[0].Type)
		if receiverType == "" {
			continue
		}

		// Find the table for this struct
		table, ok := structMap[receiverType]
		if !ok {
			continue
		}

		// Parse the return value (this is redundant with the bun tag, but provides verification)
		tableName, schemaName := r.parseTableNameMethod(funcDecl)
		if tableName != "" {
			table.Name = tableName
			if schemaName != "" {
				table.Schema = schemaName
			}

			// Update columns
			for _, col := range table.Columns {
				col.Table = tableName
				col.Schema = table.Schema
			}
		}
	}

	return tables, nil
}

// getReceiverType extracts the type name from a receiver
func (r *Reader) getReceiverType(expr ast.Expr) string {
	switch t := expr.(type) {
	case *ast.Ident:
		return t.Name
	case *ast.StarExpr:
		if ident, ok := t.X.(*ast.Ident); ok {
			return ident.Name
		}
	}
	return ""
}

// parseTableNameMethod parses a TableName() method and extracts the table and schema name
func (r *Reader) parseTableNameMethod(funcDecl *ast.FuncDecl) (tableName string, schemaName string) {
	if funcDecl.Body == nil {
		return "", ""
	}

	// Look for return statement
	for _, stmt := range funcDecl.Body.List {
		retStmt, ok := stmt.(*ast.ReturnStmt)
		if !ok {
			continue
		}

		if len(retStmt.Results) == 0 {
			continue
		}

		// Get the return value (should be a string literal)
		if basicLit, ok := retStmt.Results[0].(*ast.BasicLit); ok {
			if basicLit.Kind == token.STRING {
				// Remove quotes
				fullName := strings.Trim(basicLit.Value, "\"")

				// Split schema.table
				if strings.Contains(fullName, ".") {
					parts := strings.SplitN(fullName, ".", 2)
					return parts[1], parts[0]
				}

				return fullName, "public"
			}
		}
	}

	return "", ""
}

// hasModelFields checks if the struct has fields with bun tags
func (r *Reader) hasModelFields(structType *ast.StructType) bool {
	for _, field := range structType.Fields.List {
		if field.Tag != nil {
			tag := field.Tag.Value
			if strings.Contains(tag, "bun:") {
				return true
			}
		}
	}
	return false
}

// parseStruct converts an AST struct to a Table model
func (r *Reader) parseStruct(structName string, structType *ast.StructType) *models.Table {
	// Extract table name from the first field's bun tag if present
	tableName := ""
	schemaName := "public"

	// Look for table name in struct tags
	for _, field := range structType.Fields.List {
		if field.Tag != nil {
			tag := field.Tag.Value
			if strings.Contains(tag, "bun:\"table:") {
				tableName, schemaName = r.extractTableNameFromTag(tag)
				break
			}
		}
	}

	// If no table name found, derive from struct name
	if tableName == "" {
		tableName = r.deriveTableName(structName)
	}

	table := models.InitTable(tableName, schemaName)
	sequence := uint(1)

	// Parse fields
	for _, field := range structType.Fields.List {
		if field.Tag == nil {
			continue
		}

		tag := field.Tag.Value
		if !strings.Contains(tag, "bun:") {
			continue
		}

		// Skip BaseModel and relationship fields
		if r.isBaseModel(field) || r.isRelationship(tag) {
			continue
		}

		// Get field name
		fieldName := ""
		if len(field.Names) > 0 {
			fieldName = field.Names[0].Name
		}

		// Parse column from tag
		column := r.parseColumn(fieldName, field.Type, tag, sequence)
		if column != nil {
			column.Table = tableName
			column.Schema = schemaName
			table.Columns[column.Name] = column
			sequence++
		}
	}

	return table
}

// isBaseModel checks if a field is bun.BaseModel
func (r *Reader) isBaseModel(field *ast.Field) bool {
	if len(field.Names) > 0 {
		return false // BaseModel is embedded, so it has no name
	}

	// Check if the type is bun.BaseModel
	selExpr, ok := field.Type.(*ast.SelectorExpr)
	if !ok {
		return false
	}

	ident, ok := selExpr.X.(*ast.Ident)
	if !ok {
		return false
	}

	return ident.Name == "bun" && selExpr.Sel.Name == "BaseModel"
}

// isRelationship checks if a field is a relationship based on bun tag
func (r *Reader) isRelationship(tag string) bool {
	return strings.Contains(tag, "bun:\"rel:") || strings.Contains(tag, ",rel:")
}

// extractTableNameFromTag extracts table and schema from bun tag
func (r *Reader) extractTableNameFromTag(tag string) (tableName string, schemaName string) {
	// Extract bun tag value
	re := regexp.MustCompile(`bun:"table:([^"]+)"`)
	matches := re.FindStringSubmatch(tag)
	if len(matches) < 2 {
		return "", "public"
	}

	tablePart := matches[1]
	parts := strings.Split(tablePart, ",")
	fullName := parts[0]

	// Split schema.table
	if strings.Contains(fullName, ".") {
		schemaParts := strings.SplitN(fullName, ".", 2)
		return schemaParts[1], schemaParts[0]
	}

	return fullName, "public"
}

// deriveTableName derives a table name from struct name
func (r *Reader) deriveTableName(structName string) string {
	// Remove "Model" prefix if present
	name := strings.TrimPrefix(structName, "Model")

	// Convert PascalCase to snake_case
	var result strings.Builder
	for i, r := range name {
		if i > 0 && r >= 'A' && r <= 'Z' {
			result.WriteRune('_')
		}
		result.WriteRune(r)
	}

	return strings.ToLower(result.String())
}

// parseColumn parses a struct field into a Column model
func (r *Reader) parseColumn(fieldName string, fieldType ast.Expr, tag string, sequence uint) *models.Column {
	// Extract bun tag
	bunTag := r.extractBunTag(tag)
	if bunTag == "" {
		return nil
	}

	column := models.InitColumn("", "", "")
	column.Sequence = sequence

	// Parse bun tag
	parts := strings.Split(bunTag, ",")
	if len(parts) > 0 {
		column.Name = parts[0]
	}

	// Parse tag attributes
	for _, part := range parts[1:] {
		kv := strings.SplitN(part, ":", 2)
		key := kv[0]
		value := ""
		if len(kv) > 1 {
			value = kv[1]
		}

		switch key {
		case "type":
			// Parse type and extract length if present (e.g., varchar(255))
			column.Type, column.Length = r.parseTypeWithLength(value)
		case "pk":
			column.IsPrimaryKey = true
		case "notnull":
			column.NotNull = true
		case "autoincrement":
			column.AutoIncrement = true
		case "default":
			column.Default = value
		}
	}

	// If no type specified in tag, derive from Go type
	if column.Type == "" {
		column.Type = r.goTypeToSQL(fieldType)
	}

	// Determine if nullable based on Go type
	if r.isNullableType(fieldType) {
		column.NotNull = false
	} else if !column.IsPrimaryKey && column.Type != "" {
		// If it's not a nullable type and not a primary key, check the tag
		if !strings.Contains(bunTag, "notnull") {
			// If notnull is not explicitly set, it might still be nullable
			// This is a heuristic - we default to nullable unless specified
			return column
		}
	}

	return column
}

// extractBunTag extracts the bun tag value from a struct tag
func (r *Reader) extractBunTag(tag string) string {
	// Remove backticks
	tag = strings.Trim(tag, "`")

	// Use reflect.StructTag to properly parse
	st := reflect.StructTag(tag)
	return st.Get("bun")
}

// parseTypeWithLength parses a type string and extracts length if present
// e.g., "varchar(255)" returns ("varchar", 255)
func (r *Reader) parseTypeWithLength(typeStr string) (baseType string, length int) {
	// Check for type with length: varchar(255), char(10), etc.
	re := regexp.MustCompile(`^([a-zA-Z\s]+)\((\d+)\)$`)
	matches := re.FindStringSubmatch(typeStr)
	if len(matches) == 3 {
		if _, err := fmt.Sscanf(matches[2], "%d", &length); err == nil {
			baseType = strings.TrimSpace(matches[1])
			return
		}
	}
	baseType = typeStr
	return
}

// goTypeToSQL maps Go types to SQL types
func (r *Reader) goTypeToSQL(expr ast.Expr) string {
	switch t := expr.(type) {
	case *ast.Ident:
		switch t.Name {
		case "int", "int32":
			return "integer"
		case "int64":
			return "bigint"
		case "string":
			return "text"
		case "bool":
			return "boolean"
		case "float32":
			return "real"
		case "float64":
			return "double precision"
		}
	case *ast.SelectorExpr:
		// Handle types like time.Time, sql_types.SqlString, etc.
		if ident, ok := t.X.(*ast.Ident); ok {
			switch ident.Name {
			case "time":
				if t.Sel.Name == "Time" {
					return "timestamp"
				}
			case "resolvespec_common", "sql_types":
				return r.sqlTypeToSQL(t.Sel.Name)
			}
		}
	case *ast.StarExpr:
		// Pointer type - nullable version
		return r.goTypeToSQL(t.X)
	}
	return "text"
}

// sqlTypeToSQL maps sql_types types to SQL types
func (r *Reader) sqlTypeToSQL(typeName string) string {
	switch typeName {
	case "SqlString":
		return "text"
	case "SqlInt":
		return "integer"
	case "SqlInt64":
		return "bigint"
	case "SqlFloat":
		return "double precision"
	case "SqlBool":
		return "boolean"
	case "SqlTime":
		return "timestamp"
	default:
		return "text"
	}
}

// isNullableType checks if a Go type represents a nullable field
func (r *Reader) isNullableType(expr ast.Expr) bool {
	switch t := expr.(type) {
	case *ast.StarExpr:
		// Pointer type is nullable
		return true
	case *ast.SelectorExpr:
		// Check for sql_types nullable types
		if ident, ok := t.X.(*ast.Ident); ok {
			if ident.Name == "resolvespec_common" || ident.Name == "sql_types" {
				return strings.HasPrefix(t.Sel.Name, "Sql")
			}
		}
	}
	return false
}