package database

import (
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func TestGetString(t *testing.T) {
	t.Run("existing string key", func(t *testing.T) {
		m := map[string]interface{}{"key": "value"}
		result := GetString(m, "key")
		assert.Equal(t, "value", result)
	})

	t.Run("non-existing key", func(t *testing.T) {
		m := map[string]interface{}{}
		result := GetString(m, "key")
		assert.Equal(t, "", result)
	})

	t.Run("non-string value", func(t *testing.T) {
		m := map[string]interface{}{"key": 123}
		result := GetString(m, "key")
		assert.Equal(t, "", result)
	})
}

func TestGetFloat64(t *testing.T) {
	t.Run("float64 value", func(t *testing.T) {
		m := map[string]interface{}{"key": 3.14}
		result := GetFloat64(m, "key")
		assert.Equal(t, 3.14, result)
	})

	t.Run("int64 value", func(t *testing.T) {
		m := map[string]interface{}{"key": int64(42)}
		result := GetFloat64(m, "key")
		assert.Equal(t, 42.0, result)
	})

	t.Run("int value", func(t *testing.T) {
		m := map[string]interface{}{"key": 42}
		result := GetFloat64(m, "key")
		assert.Equal(t, 42.0, result)
	})

	t.Run("non-existing key", func(t *testing.T) {
		m := map[string]interface{}{}
		result := GetFloat64(m, "key")
		assert.Equal(t, 0.0, result)
	})

	t.Run("non-numeric value", func(t *testing.T) {
		m := map[string]interface{}{"key": "string"}
		result := GetFloat64(m, "key")
		assert.Equal(t, 0.0, result)
	})
}

func TestGetInt(t *testing.T) {
	t.Run("int64 value", func(t *testing.T) {
		m := map[string]interface{}{"key": int64(42)}
		result := GetInt(m, "key")
		assert.Equal(t, 42, result)
	})

	t.Run("int value", func(t *testing.T) {
		m := map[string]interface{}{"key": 42}
		result := GetInt(m, "key")
		assert.Equal(t, 42, result)
	})

	t.Run("float64 value", func(t *testing.T) {
		m := map[string]interface{}{"key": 42.0}
		result := GetInt(m, "key")
		assert.Equal(t, 42, result)
	})

	t.Run("non-existing key", func(t *testing.T) {
		m := map[string]interface{}{}
		result := GetInt(m, "key")
		assert.Equal(t, 0, result)
	})

	t.Run("non-numeric value", func(t *testing.T) {
		m := map[string]interface{}{"key": "string"}
		result := GetInt(m, "key")
		assert.Equal(t, 0, result)
	})
}

func TestGetBool(t *testing.T) {
	t.Run("true value", func(t *testing.T) {
		m := map[string]interface{}{"key": true}
		result := GetBool(m, "key")
		assert.True(t, result)
	})

	t.Run("false value", func(t *testing.T) {
		m := map[string]interface{}{"key": false}
		result := GetBool(m, "key")
		assert.False(t, result)
	})

	t.Run("non-existing key", func(t *testing.T) {
		m := map[string]interface{}{}
		result := GetBool(m, "key")
		assert.False(t, result)
	})

	t.Run("non-bool value", func(t *testing.T) {
		m := map[string]interface{}{"key": "string"}
		result := GetBool(m, "key")
		assert.False(t, result)
	})
}

func TestGetTime(t *testing.T) {
	testTime := time.Now()

	t.Run("time.Time value", func(t *testing.T) {
		m := map[string]interface{}{"key": testTime}
		result := GetTime(m, "key")
		assert.Equal(t, testTime, result)
	})

	t.Run("RFC3339 string value", func(t *testing.T) {
		timeStr := "2023-01-01T12:00:00Z"
		m := map[string]interface{}{"key": timeStr}
		result := GetTime(m, "key")
		expected, _ := time.Parse(time.RFC3339, timeStr)
		assert.Equal(t, expected, result)
	})

	t.Run("invalid string value", func(t *testing.T) {
		m := map[string]interface{}{"key": "invalid"}
		result := GetTime(m, "key")
		assert.True(t, result.IsZero())
	})

	t.Run("non-existing key", func(t *testing.T) {
		m := map[string]interface{}{}
		result := GetTime(m, "key")
		assert.True(t, result.IsZero())
	})

	t.Run("non-time value", func(t *testing.T) {
		m := map[string]interface{}{"key": 123}
		result := GetTime(m, "key")
		assert.True(t, result.IsZero())
	})
}