package processor

import (
	"fmt"
	"strings"

	lua "github.com/yuin/gopher-lua"
)

// Processor defines the interface for all file processors
type Processor interface {
	// Process handles processing a file with the given pattern and Lua expression
	Process(filename string, pattern string, luaExpr string) (int, int, error)

	// ProcessContent handles processing a string content directly with the given pattern and Lua expression
	// Returns the modified content, modification count, match count, and any error
	ProcessContent(content string, pattern string, luaExpr string) (string, int, int, error)

	// ToLua converts processor-specific data to Lua variables
	ToLua(L *lua.LState, data interface{}) error

	// FromLua retrieves modified data from Lua
	FromLua(L *lua.LState) (interface{}, error)
}

// ModificationRecord tracks a single value modification
type ModificationRecord struct {
	File      string
	OldValue  string
	NewValue  string
	Operation string
	Context   string
}

// InitLuaHelpers initializes common Lua helper functions
func InitLuaHelpers(L *lua.LState) error {
	helperScript := `
-- Custom Lua helpers for math operations
function min(a, b) return math.min(a, b) end
function max(a, b) return math.max(a, b) end
function round(x) return math.floor(x + 0.5) end
function floor(x) return math.floor(x) end
function ceil(x) return math.ceil(x) end
function upper(s) return string.upper(s) end
function lower(s) return string.lower(s) end

-- String to number conversion helper
function num(str)
    return tonumber(str) or 0
end

-- Number to string conversion
function str(num)
    return tostring(num)
end

-- Check if string is numeric
function is_number(str)
    return tonumber(str) ~= nil
end
`
	if err := L.DoString(helperScript); err != nil {
		return fmt.Errorf("error loading helper functions: %v", err)
	}
	return nil
}

// Helper utility functions

// LimitString truncates a string to maxLen and adds "..." if truncated
func LimitString(s string, maxLen int) string {
	s = strings.ReplaceAll(s, "\n", "\\n")
	if len(s) <= maxLen {
		return s
	}
	return s[:maxLen-3] + "..."
}

// BuildLuaScript prepares a Lua expression from shorthand notation
func BuildLuaScript(luaExpr string) string {
	// Auto-prepend v1 for expressions starting with operators
	if strings.HasPrefix(luaExpr, "*") ||
		strings.HasPrefix(luaExpr, "/") ||
		strings.HasPrefix(luaExpr, "+") ||
		strings.HasPrefix(luaExpr, "-") ||
		strings.HasPrefix(luaExpr, "^") ||
		strings.HasPrefix(luaExpr, "%") {
		luaExpr = "v1 = v1" + luaExpr
	} else if strings.HasPrefix(luaExpr, "=") {
		// Handle direct assignment with = operator
		luaExpr = "v1 " + luaExpr
	}

	// Add assignment if needed
	if !strings.Contains(luaExpr, "=") {
		luaExpr = "v1 = " + luaExpr
	}

	return luaExpr
}

// Max returns the maximum of two integers
func Max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// Min returns the minimum of two integers
func Min(a, b int) int {
	if a < b {
		return a
	}
	return b
}