package FikoYTMap

import (
	"reflect"

	"github.com/gofiber/fiber/v3"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type FikoYTMap fiber.Map

func (f FikoYTMap) BosAlanlar() []string {
	var bosAlanlar []string

	for key, value := range f {
		if value == nil {
			// fmt.Printf("Alan boş veya nil: %s\n", key)
			bosAlanlar = append(bosAlanlar, key)
		}
		v := reflect.ValueOf(value)
		if v.Kind() == reflect.String && v.Len() == 0 {
			// fmt.Printf("Alan boş string: %s\n", key)
			bosAlanlar = append(bosAlanlar, key)
		}
		if v.Kind() == reflect.Bool && !v.Bool() {
			// fmt.Printf("Alan boş string: %s\n", key)
			bosAlanlar = append(bosAlanlar, key)
		}
	}
	return bosAlanlar
}

func (f FikoYTMap) TumAlanlarDolumu() bool {
	for _, value := range f {
		if value == nil {
			// fmt.Printf("Alan boş veya nil: %s\n", key)
			return false
		}
		v := reflect.ValueOf(value)
		if v.Kind() == reflect.String && v.Len() == 0 {
			// fmt.Printf("Alan boş string: %s\n", key)
			return false
		}
		if v.Kind() == reflect.Bool && !v.Bool() {
			// fmt.Printf("Alan boş string: %s\n", key)
			return false
		}
	}
	return true
}

func (f FikoYTMap) IsleObjectId() FikoYTMap {
	for key, value := range f {
		switch v := value.(type) {
		case string:
			if len(v) == 24 {
				if objectId, err := primitive.ObjectIDFromHex(v); err == nil {
					f[key] = objectId
				}
			}
		case map[string]interface{}:
			// Alt map için recursive dönüşüm
			f[key] = FikoYTMap(v).IsleObjectId()
		case FikoYTMap:
			// Zaten FikoYTMap ise recursive dönüşüm
			f[key] = v.IsleObjectId()
		case []interface{}:
			// Liste ise her elemanı tek tek dönüştür
			f[key] = convertSliceObjectIds(v)
		}
	}
	return f
}

// Yardımcı fonksiyon
func convertSliceObjectIds(slice []interface{}) []interface{} {
	for i, elem := range slice {
		switch e := elem.(type) {
		case string:
			if len(e) == 24 {
				if objectId, err := primitive.ObjectIDFromHex(e); err == nil {
					slice[i] = objectId
				}
			}
		case map[string]interface{}:
			slice[i] = FikoYTMap(e).IsleObjectId()
		case FikoYTMap:
			slice[i] = e.IsleObjectId()
		case []interface{}:
			slice[i] = convertSliceObjectIds(e) // iç içe slice varsa
		}
	}
	return slice
}

func (f FikoYTMap) ToBsonM() bson.M {
	return toBsonM(f)
}

func toBsonM(f FikoYTMap) bson.M {
	result := bson.M{}
	for k, v := range f {
		switch val := v.(type) {
		case map[string]interface{}:
			result[k] = toBsonM(val) // recursive dönüşüm
		case []interface{}:
			result[k] = convertSlice(val)
		default:
			result[k] = val
		}
	}
	return result
}

func convertSlice(arr []interface{}) []interface{} {
	for i, v := range arr {
		switch elem := v.(type) {
		case map[string]interface{}:
			arr[i] = toBsonM(elem)
		case []interface{}:
			arr[i] = convertSlice(elem) // nested array
		}
	}
	return arr
}