package domain

import (
	"encoding/json"
	"fmt"
	"strconv"
	"time"

	"github.com/jackc/pgx/v5/pgtype"
)

type ValidInt64 struct {
	Value int64
	Valid bool
}
type ValidInt struct {
	Value int
	Valid bool
}
type ValidInt32 struct {
	Value int32
	Valid bool
}

type ValidFloat32 struct {
	Value float32
	Valid bool
}

type ValidString struct {
	Value string
	Valid bool
}
type ValidTime struct {
	Value time.Time
	Valid bool
}
type ValidBool struct {
	Value bool
	Valid bool
}

// ValidInt64 → pgtype.Int8
func (v ValidInt64) ToPG() pgtype.Int8 {
	return pgtype.Int8{
		Int64: v.Value,
		Valid: v.Valid,
	}
}

// ValidInt32 → pgtype.Int4
func (v ValidInt32) ToPG() pgtype.Int4 {
	return pgtype.Int4{
		Int32: v.Value,
		Valid: v.Valid,
	}
}

// ValidInt → pgtype.Int4 (Go int mapped to int32 for pg compatibility)
func (v ValidInt) ToPG() pgtype.Int4 {
	return pgtype.Int4{
		Int32: int32(v.Value),
		Valid: v.Valid,
	}
}

// ValidFloat32 → pgtype.Float4
func (v ValidFloat32) ToPG() pgtype.Float4 {
	return pgtype.Float4{
		Float32: v.Value,
		Valid:   v.Valid,
	}
}

// ValidString → pgtype.Text
func (v ValidString) ToPG() pgtype.Text {
	return pgtype.Text{
		String: v.Value,
		Valid:  v.Valid,
	}
}

// ValidTime → pgtype.Timestamp
func (v ValidTime) ToPG() pgtype.Timestamp {
	return pgtype.Timestamp{
		Time:  v.Value,
		Valid: v.Valid,
	}
}

// ValidBool → pgtype.Bool
func (v ValidBool) ToPG() pgtype.Bool {
	return pgtype.Bool{
		Bool:  v.Value,
		Valid: v.Valid,
	}
}

func ConvertInt64Ptr(value *int64) ValidInt64 {
	if value == nil {
		return ValidInt64{}
	}
	return ValidInt64{
		Value: *value,
		Valid: true,
	}
}

func ConvertInt32Ptr(value *int32) ValidInt32 {
	if value == nil {
		return ValidInt32{}
	}
	return ValidInt32{
		Value: *value,
		Valid: true,
	}
}

func ConvertStringPtr(value *string) ValidString {
	if value == nil {
		return ValidString{}
	}
	return ValidString{
		Value: *value,
		Valid: true,
	}
}

func ConvertFloat32Ptr(value *float32) ValidFloat32 {
	if value == nil {
		return ValidFloat32{}
	}
	return ValidFloat32{
		Value: *value,
		Valid: true,
	}
}

func ConvertCurrencyFloatPtr(value *float32) ValidInt64 {
	if value == nil {
		return ValidInt64{}
	}

	convertedCurrency := ToCurrency(*value)

	return ValidInt64{
		Value: int64(convertedCurrency),
		Valid: true,
	}
}

func ConvertBoolPtr(value *bool) ValidBool {
	if value == nil {
		return ValidBool{}
	}
	return ValidBool{
		Value: *value,
		Valid: true,
	}
}

func (n *ValidInt64) UnmarshalJSON(data []byte) error {
	var s string
	if err := json.Unmarshal(data, &s); err == nil {
		if s == "" {
			n.Valid = false
			return nil
		}
		v, err := strconv.ParseInt(s, 10, 64)
		if err != nil {
			return err
		}
		n.Value, n.Valid = v, true
		return nil
	}

	var v int64
	if err := json.Unmarshal(data, &v); err == nil {
		n.Value, n.Valid = v, true
		return nil
	}

	return fmt.Errorf("invalid int64 value: %s", string(data))
}