package pgDB

import (
	"database/sql/driver"
	"fmt"
	"strconv"
	"strings"
)

type Cube []float64

func (c Cube) Value() (driver.Value, error) {
	if len(c) == 0 {
		return nil, nil
	}
	var sb strings.Builder
	sb.WriteString("(")
	for i, v := range c {
		if i > 0 {
			sb.WriteString(",")
		}
		sb.WriteString(strconv.FormatFloat(v, 'f', -1, 64))
	}
	sb.WriteString(")")
	return sb.String(), nil
}

func (c *Cube) Scan(value interface{}) error {
	if value == nil {
		*c = nil
		return nil
	}

	switch v := value.(type) {
	case []byte:
		return c.parseCubeString(string(v))
	case string:
		return c.parseCubeString(v)
	default:
		return fmt.Errorf("unsupported type for cube: %T", value)
	}
}

func (c *Cube) parseCubeString(s string) error {
	s = strings.Trim(s, "()")
	if s == "" {
		*c = Cube{}
		return nil
	}

	parts := strings.Split(s, ",")
	cube := make(Cube, len(parts))
	for i, part := range parts {
		val, err := strconv.ParseFloat(strings.TrimSpace(part), 64)
		if err != nil {
			return fmt.Errorf("failed to parse cube value: %v", err)
		}
		cube[i] = val
	}

	*c = cube
	return nil
}

func (c Cube) Float64SliceToCubeString() string {
	if len(c) == 0 {
		return "()"
	}

	var b strings.Builder
	b.WriteString("(")

	for i, v := range c {
		if i > 0 {
			b.WriteString(",")
		}
		b.WriteString(fmt.Sprintf("%g", v))
	}

	b.WriteString(")")
	return b.String()
}