// functions/string.go
package functions

import (
	"fmt"
	"strings"

	luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
)

// GetStringFunctions returns all string manipulation Go functions
func GetStringFunctions() map[string]luajit.GoFunction {
	return map[string]luajit.GoFunction{
		"string_split": func(s *luajit.State) int {
			if err := s.CheckExactArgs(2); err != nil {
				return s.PushError("string_split: %v", err)
			}

			str, err := s.SafeToString(1)
			if err != nil {
				return s.PushError("string_split: first argument must be a string")
			}

			sep, err := s.SafeToString(2)
			if err != nil {
				return s.PushError("string_split: second argument must be a string")
			}

			parts := strings.Split(str, sep)
			if err := s.PushValue(parts); err != nil {
				return s.PushError("string_split: failed to push result: %v", err)
			}

			return 1
		},

		"string_join": func(s *luajit.State) int {
			if err := s.CheckExactArgs(2); err != nil {
				return s.PushError("string_join: %v", err)
			}

			arr, err := s.SafeToTable(1)
			if err != nil {
				return s.PushError("string_join: first argument must be a table")
			}

			sep, err := s.SafeToString(2)
			if err != nil {
				return s.PushError("string_join: second argument must be a string")
			}

			var parts []string
			if slice, ok := arr.([]string); ok {
				parts = slice
			} else if anySlice, ok := arr.([]interface{}); ok {
				parts = make([]string, len(anySlice))
				for i, v := range anySlice {
					parts[i] = fmt.Sprintf("%v", v)
				}
			} else {
				return s.PushError("string_join: first argument must be an array")
			}

			result := strings.Join(parts, sep)
			s.PushString(result)
			return 1
		},

		"string_trim": func(s *luajit.State) int {
			if err := s.CheckMinArgs(1); err != nil {
				return s.PushError("string_trim: %v", err)
			}

			str, err := s.SafeToString(1)
			if err != nil {
				return s.PushError("string_trim: argument must be a string")
			}

			s.PushString(strings.TrimSpace(str))
			return 1
		},

		"string_upper": func(s *luajit.State) int {
			if err := s.CheckMinArgs(1); err != nil {
				return s.PushError("string_upper: %v", err)
			}

			str, err := s.SafeToString(1)
			if err != nil {
				return s.PushError("string_upper: argument must be a string")
			}

			s.PushString(strings.ToUpper(str))
			return 1
		},

		"string_lower": func(s *luajit.State) int {
			if err := s.CheckMinArgs(1); err != nil {
				return s.PushError("string_lower: %v", err)
			}

			str, err := s.SafeToString(1)
			if err != nil {
				return s.PushError("string_lower: argument must be a string")
			}

			s.PushString(strings.ToLower(str))
			return 1
		},

		"string_contains": func(s *luajit.State) int {
			if err := s.CheckExactArgs(2); err != nil {
				return s.PushError("string_contains: %v", err)
			}

			str, err := s.SafeToString(1)
			if err != nil {
				return s.PushError("string_contains: first argument must be a string")
			}

			substr, err := s.SafeToString(2)
			if err != nil {
				return s.PushError("string_contains: second argument must be a string")
			}

			s.PushBoolean(strings.Contains(str, substr))
			return 1
		},

		"string_replace": func(s *luajit.State) int {
			if err := s.CheckExactArgs(3); err != nil {
				return s.PushError("string_replace: %v", err)
			}

			str, err := s.SafeToString(1)
			if err != nil {
				return s.PushError("string_replace: first argument must be a string")
			}

			old, err := s.SafeToString(2)
			if err != nil {
				return s.PushError("string_replace: second argument must be a string")
			}

			new, err := s.SafeToString(3)
			if err != nil {
				return s.PushError("string_replace: third argument must be a string")
			}

			result := strings.ReplaceAll(str, old, new)
			s.PushString(result)
			return 1
		},
	}
}