package utils

import (
	"fmt"
	"hash/maphash"
	"sync"
)

// 泛型有序Map的实现，结合了SliceMap的并发安全和orderedMap的有序性及高效查找

// MapEntry 表示Map中的一个键值对条目
type MapEntry[K comparable, V any] struct {
	key   K
	value V

	// 用于维护插入顺序的双向链表指针
	prev, next *MapEntry[K, V]
	// 用于哈希表碰撞处理的链表指针
	hashNext *MapEntry[K, V]
	// 标记是否被删除
	deleted bool
}

// OrderedMap 是一个泛型的有序Map实现
type OrderedMap[K comparable, V any] struct {
	mu        sync.RWMutex               // 并发安全锁
	hash      *maphash.Hash              // 哈希计算器
	hashTable map[uint64]*MapEntry[K, V] // 哈希表，用于快速查找
	first     *MapEntry[K, V]            // 双向链表头，维护插入顺序
	last      *MapEntry[K, V]            // 双向链表尾，维护插入顺序
	size      int                        // 当前元素数量（排除已删除的）
}

// NewOrderedMap 创建一个新的泛型有序Map
func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V] {
	return &OrderedMap[K, V]{
		hash: &maphash.Hash{},

		hashTable: make(map[uint64]*MapEntry[K, V]),
	}
}

// 计算键的哈希值
func (m *OrderedMap[K, V]) hashKey(key K) uint64 {
	// 这里简化实现，实际使用中可能需要根据K的类型做特殊处理
	// 对于基本类型可以直接写入，复杂类型可能需要序列化
	m.hash.Reset()
	// 注意：实际使用时需要根据K的具体类型实现正确的哈希计算
	// 这里只是示例，可能需要调整
	m.hash.WriteString(fmt.Sprintf("%v", key))
	return m.hash.Sum64()
}

// 查找键对应的条目
func (m *OrderedMap[K, V]) lookup(key K) (hash uint64, entry, prevEntry *MapEntry[K, V]) {
	hash = m.hashKey(key)
	for entry = m.hashTable[hash]; entry != nil; prevEntry, entry = entry, entry.hashNext {
		if !entry.deleted && entry.key == key {
			break
		}
	}
	return
}

// Store 存储键值对，如果键已存在则更新值
func (m *OrderedMap[K, V]) Store(key K, value V) {
	m.mu.Lock()
	defer m.mu.Unlock()

	hash, entry, prevEntry := m.lookup(key)

	if entry != nil {
		// 键已存在，更新值并确保标记为未删除
		entry.value = value
		if entry.deleted {
			entry.deleted = false
			m.size++
		}
		return
	}

	// 创建新条目
	entry = &MapEntry[K, V]{
		key:   key,
		value: value,
	}

	// 添加到哈希表
	if prevEntry == nil {
		m.hashTable[hash] = entry
	} else {
		prevEntry.hashNext = entry
	}

	// 添加到双向链表末尾以保持插入顺序
	if m.last != nil {
		entry.prev = m.last
		m.last.next = entry
	} else {
		// 第一个元素
		m.first = entry
	}
	m.last = entry
	m.size++
}

// Load 查找并返回键对应的值，如果不存在则返回零值和false
func (m *OrderedMap[K, V]) Load(key K) (value V, exists bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()

	_, entry, _ := m.lookup(key)
	if entry != nil && !entry.deleted {
		return entry.value, true
	}
	return value, false
}

// LoadOrStore 查找并返回键对应的值，如果不存在则存储并返回给定值
func (m *OrderedMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
	m.mu.Lock()
	defer m.mu.Unlock()

	_, entry, _ := m.lookup(key)
	if entry != nil && !entry.deleted {
		return entry.value, true
	}

	// 执行存储操作
	hash := m.hashKey(key)
	entry = &MapEntry[K, V]{
		key:   key,
		value: value,
	}

	// 添加到哈希表
	if m.hashTable[hash] == nil {
		m.hashTable[hash] = entry
	} else {
		// 处理哈希冲突
		last := m.hashTable[hash]
		for last.hashNext != nil {
			last = last.hashNext
		}
		last.hashNext = entry
	}

	// 添加到双向链表
	if m.last != nil {
		entry.prev = m.last
		m.last.next = entry
	} else {
		m.first = entry
	}
	m.last = entry
	m.size++

	return value, false
}

// Delete 标记删除指定的键
func (m *OrderedMap[K, V]) Delete(key K) {
	m.mu.Lock()
	defer m.mu.Unlock()

	_, entry, _ := m.lookup(key)
	if entry != nil && !entry.deleted {
		entry.deleted = true
		m.size--
	}
}

// Range 按插入顺序迭代Map中的所有键值对
// 如果f返回false，则停止迭代
func (m *OrderedMap[K, V]) Range(f func(key K, value V) bool) {
	m.mu.RLock()
	defer m.mu.RUnlock()

	current := m.first
	for current != nil {
		if !current.deleted {
			if !f(current.key, current.value) {
				return
			}
		}
		current = current.next
	}
}

// Len 返回当前Map中的元素数量（排除已删除的）
func (m *OrderedMap[K, V]) Len() int {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return m.size
}

// Clear 清空Map中的所有元素
func (m *OrderedMap[K, V]) Clear() {
	m.mu.Lock()
	defer m.mu.Unlock()

	// 重置所有指针和计数器
	m.first = nil
	m.last = nil
	m.hashTable = make(map[uint64]*MapEntry[K, V])
	m.size = 0
}
