package mongo

import (
	"log"

	"go.mongodb.org/mongo-driver/v2/bson"
)

type Query struct {
	Filter map[string]any `json:"filter"`
}

type Filter struct {
	Name string `json:"name"`
	Op string `json:"op"`
	Value string `json:"value"`
}

func makeFilter(name string, value any) *Filter {
	var op string

	var v string

	log.Printf("TYPE %T", value)

	switch value.(type) {
	case string:
		op = "eq"
		v = value.(string)
	case bson.M:
		vMap := value.(bson.M)

		log.Printf("GEO its map[string]any %v", vMap)
		for kk, vv := range vMap {
			op = kk
			v = vv.(string)

			break
		}
		
	case map[string]any:
		vMap := value.(map[string]any)

		log.Printf("GEO its bson.M %v", vMap)
		for kk, vv := range vMap {
			op = kk
			v = vv.(string)

			break
		}
		
	default:
		op = "eq"
	}

	o := &Filter{
		Name: name,
		Op: op,
		Value: v,
	}

	log.Printf("FILTER -> %#v", o)

	return o
}

func Mongofy(q *Query) map[string]any {

	conditions := make([]map[string]interface{}, 0)

	logic := "and"
log.Printf("GEO q.Filter %#v", q.Filter)
	for k, v := range q.Filter {
		if k == "_logic" {
			logic = v.(string)

			continue
		}

		f := makeFilter(k, v)

		mongoOp := mapToOp(f.Op)

		conditions = append(conditions, map[string]any{ k: map[string]any{ mongoOp: f.Value }})
	}

	if len(conditions) == 0 {
		return map[string]any{}
	}

	if logic == "or" {
		return map[string]any{
			"$or": conditions,
		}
	}

	return map[string]any{
		"$and": conditions,
	}
}

func mapToOp(v string) string {
	switch v {
	case "eq":
		return "$eq"
	case "includes": 
		return "$regex"
	default:
		log.Printf("WARN: no conversion")
		return v
	}
}