// if_control — 單一條件判斷，true/false 兩個出口
// condition 支援：key（truthy）、key == value、key > number、key < number
package main

import (
	"encoding/json"
	"io"
	"os"
	"strconv"
	"strings"
)

type Input struct {
	Condition string                 `json:"condition"`
	Input     map[string]interface{} `json:"input"`
}

func main() {
	raw, err := io.ReadAll(os.Stdin)
	if err != nil {
		writeError("failed to read stdin: " + err.Error())
		return
	}
	var input Input
	if err := json.Unmarshal(raw, &input); err != nil {
		writeError("invalid input JSON: " + err.Error())
		return
	}
	if input.Condition == "" {
		writeError("condition 必填")
		return
	}

	result := evaluateCondition(input.Condition, input.Input)
	branch := "false"
	if result {
		branch = "true"
	}

	out, _ := json.Marshal(map[string]interface{}{
		"success": true,
		"data":    map[string]interface{}{"result": result, "branch": branch},
	})
	os.Stdout.Write(out)
}

func toString(v interface{}) string {
	switch val := v.(type) {
	case string:
		return val
	case float64:
		return strconv.FormatFloat(val, 'f', -1, 64)
	case bool:
		if val {
			return "true"
		}
		return "false"
	case nil:
		return ""
	default:
		b, _ := json.Marshal(val)
		return string(b)
	}
}

func evaluateCondition(condition string, ctx map[string]interface{}) bool {
	if ctx == nil {
		return false
	}
	expr := strings.TrimSpace(condition)

	// key == value
	if idx := strings.Index(expr, "=="); idx > 0 {
		key := strings.TrimSpace(expr[:idx])
		expected := strings.Trim(strings.TrimSpace(expr[idx+2:]), `"'`)
		v, ok := ctx[key]
		if !ok {
			return false
		}
		return toString(v) == expected
	}
	// key > number
	if idx := strings.Index(expr, ">"); idx > 0 {
		key := strings.TrimSpace(expr[:idx])
		threshold, err := strconv.ParseFloat(strings.TrimSpace(expr[idx+1:]), 64)
		if err != nil {
			return false
		}
		v, ok := ctx[key]
		if !ok {
			return false
		}
		n, err := strconv.ParseFloat(toString(v), 64)
		if err != nil {
			return false
		}
		return n > threshold
	}
	// key < number
	if idx := strings.Index(expr, "<"); idx > 0 {
		key := strings.TrimSpace(expr[:idx])
		threshold, err := strconv.ParseFloat(strings.TrimSpace(expr[idx+1:]), 64)
		if err != nil {
			return false
		}
		v, ok := ctx[key]
		if !ok {
			return false
		}
		n, err := strconv.ParseFloat(toString(v), 64)
		if err != nil {
			return false
		}
		return n < threshold
	}
	// truthy check
	v, ok := ctx[expr]
	if !ok {
		return false
	}
	switch val := v.(type) {
	case bool:
		return val
	case string:
		return val != ""
	case float64:
		return val != 0
	case nil:
		return false
	default:
		return true
	}
}

func writeError(msg string) {
	out, _ := json.Marshal(map[string]interface{}{"success": false, "error": msg})
	os.Stdout.Write(out)
}
