// array_ops — 陣列操作
// 支援: count, first, last, reverse, sum, average, min, max, sort, unique
// input 陣列元素支援 float64 或 string
//
//go:build tinygo

package main

import (
	"encoding/json"
	"io"
	"math"
	"os"
	"sort"
	"strconv"
)

type Input struct {
	Operation string            `json:"operation"`
	Input     []json.RawMessage `json:"input"`
	Args      map[string]string `json:"args"`
}

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.Operation == "" {
		writeError("operation 必填")
		return
	}

	items := input.Input
	op := input.Operation

	switch op {
	case "count":
		writeResult(op, len(items))
	case "first":
		if len(items) == 0 {
			writeError("陣列為空")
			return
		}
		writeResultRaw(op, items[0])
	case "last":
		if len(items) == 0 {
			writeError("陣列為空")
			return
		}
		writeResultRaw(op, items[len(items)-1])
	case "reverse":
		reversed := make([]json.RawMessage, len(items))
		for i, v := range items {
			reversed[len(items)-1-i] = v
		}
		writeResultRaw(op, reversed)
	case "sum":
		nums, err := toFloats(items)
		if err != nil {
			writeError(err.Error())
			return
		}
		sum := 0.0
		for _, n := range nums {
			sum += n
		}
		writeResult(op, sum)
	case "average":
		nums, err := toFloats(items)
		if err != nil {
			writeError(err.Error())
			return
		}
		if len(nums) == 0 {
			writeError("陣列為空")
			return
		}
		sum := 0.0
		for _, n := range nums {
			sum += n
		}
		writeResult(op, sum/float64(len(nums)))
	case "min":
		nums, err := toFloats(items)
		if err != nil {
			writeError(err.Error())
			return
		}
		if len(nums) == 0 {
			writeError("陣列為空")
			return
		}
		m := math.MaxFloat64
		for _, n := range nums {
			if n < m {
				m = n
			}
		}
		writeResult(op, m)
	case "max":
		nums, err := toFloats(items)
		if err != nil {
			writeError(err.Error())
			return
		}
		if len(nums) == 0 {
			writeError("陣列為空")
			return
		}
		m := -math.MaxFloat64
		for _, n := range nums {
			if n > m {
				m = n
			}
		}
		writeResult(op, m)
	case "sort":
		// 嘗試數字排序，失敗則字串排序
		nums, err := toFloats(items)
		if err == nil {
			sort.Float64s(nums)
			writeResult(op, nums)
			return
		}
		strs, err2 := toStrings(items)
		if err2 != nil {
			writeError("sort 只支援數字或字串陣列")
			return
		}
		sort.Strings(strs)
		writeResult(op, strs)
	case "unique":
		seen := map[string]bool{}
		var result []json.RawMessage
		for _, item := range items {
			key := string(item)
			if !seen[key] {
				seen[key] = true
				result = append(result, item)
			}
		}
		if result == nil {
			result = []json.RawMessage{}
		}
		writeResultRaw(op, result)
	default:
		writeError("不支援的 operation: " + op)
	}
}

func toFloats(items []json.RawMessage) ([]float64, error) {
	nums := make([]float64, len(items))
	for i, item := range items {
		var n float64
		if err := json.Unmarshal(item, &n); err != nil {
			return nil, &parseError{"元素 " + strconv.Itoa(i) + " 不是數字"}
		}
		nums[i] = n
	}
	return nums, nil
}

func toStrings(items []json.RawMessage) ([]string, error) {
	strs := make([]string, len(items))
	for i, item := range items {
		var s string
		if err := json.Unmarshal(item, &s); err != nil {
			return nil, &parseError{"元素 " + strconv.Itoa(i) + " 不是字串"}
		}
		strs[i] = s
	}
	return strs, nil
}

type parseError struct{ msg string }

func (e *parseError) Error() string { return e.msg }

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

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

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