package QUEUE

import (
	"strings"
	"sync"
)

type CycleQueue struct {
	data  []interface{} //存儲空間
	front int           //前指針,前指針負責彈出數(shù)據(jù)移動
	rear  int           //尾指針,后指針負責添加數(shù)據(jù)移動
	cap   int           //設置切片最大容量
	mu    sync.RWMutex          // 添加互斥鎖
}

func NewCycleQueue(cap int) *CycleQueue {
	return &CycleQueue{
		data:  make([]interface{}, cap),
		cap:   cap,
		front: 0,
		rear:  0,
	}
}

// 入隊操作
// 判斷隊列是否隊滿,隊滿則不允許添加數(shù)據(jù)
func (q *CycleQueue) Push(data interface{}) bool {
	q.mu.Lock()
	defer q.mu.Unlock() // 確保在函數(shù)退出時釋放鎖

	//check queue is full
	if q.QueueLength() == q.cap { //隊列已滿時，不執(zhí)行入隊操作
		Log.Error("push err queue is full")
		return false
	}
	q.data[q.rear] = data         //將元素放入隊列尾部
	q.rear = (q.rear + 1) % q.cap //尾部元素指向下一個空間位置,取模運算保證了索引不越界（余數(shù)一定小于除數(shù)）
	return true
}

// 出隊操作
// 需要考慮: 隊隊為空沒有數(shù)據(jù)返回了
func (q *CycleQueue) Pop() interface{} {
	q.mu.Lock()
	defer q.mu.Unlock()

	if q.rear == q.front {
		return nil
	}

	data := q.data[q.front]
	q.data[q.front] = nil // 使用nil來避免內存泄露
	q.front = (q.front + 1) % q.cap
	return data
}

// 循環(huán)隊列長度計算，考慮哨兵空間
func (q *CycleQueue) QueueLength() int {
	if q.rear >= q.front {
		return q.rear - q.front
	}
	return q.cap - q.front + q.rear
}

func (q *CycleQueue) FindDataByRequestId(requestId string) interface{} {
	q.mu.Lock()
	defer q.mu.Unlock()

	// 計算隊列中的有效元素數(shù)量
	length := q.QueueLength()

	// 從front指針開始遍歷隊列
	index := q.front
	for i := 0; i < length; i++ {
		// 檢查當前元素是否包含requestId
		if data, ok := q.data[index].(string); ok && strings.Contains(data, requestId) {
			// 找到元素后，從隊列中移除
			q.RemoveAtIndex(index)
			return data
		}
		// 移動到下一個元素
		index = (index + 1) % q.cap
	}
	// 如果沒有找到，返回nil
	return nil
}

// 新增RemoveAtIndex方法，用于在循環(huán)隊列中移除指定索引的元素
func (q *CycleQueue) RemoveAtIndex(index int) {
	if index < 0 || index >= q.cap {
		return // 索引越界檢查
	}

	// 將index位置的元素復制到最后一個元素的位置
	copy(q.data[index:], q.data[index+1:q.rear])

	// 更新隊列的front和rear指針
	if index == q.rear { // 如果移除的是最后一個元素
		q.rear = index // rear指針向前移動
	} else if index < q.rear { // 如果移除的是中間的元素
		q.rear-- // rear指針向前移動
	}

	// 如果移除的是front指針前的元素
	if index < q.front {
		q.front = index // front指針向后移動
	}
}

package server

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

//隊列通道
type Channel struct {
    queue                  *MeetGo.CycleQueue
}

//隊列參數(shù)項
type QueueItem struct {
    event    string
    msg      map[string]interface{}
    response *chan Response
}

//返回參數(shù)
type Response struct {
	err    interface{}
	result map[string]interface{}
}

var globalChannel *Channel


//創(chuàng)建隊列通道
func NewChannel() {
    channel.queue = QUEUE.NewCycleQueue(1000)
    go channel.handle()
    return
}

//處理隊列數(shù)據(jù)
func (channel *Channel) handle() {
    for {
        item := channel.queue.Pop()

        if item == nil {
            time.Sleep(40 * time.Millisecond)
            continue
        }
        channel.process(item)
        time.Sleep(1 * time.Millisecond)
    }
}

func (channel *Channel) process(inter interface{}) {
    item := inter.(QueueItem)
}

func (channel *Channel) PushSignal(item QueueItem) {
    Channel.queue.Push(item)
}

func (channel *Channel) onRequest(event string, msg map[string]interface{}) chan Response {
	response := make(chan Response, 1)
	item := QueueItem{
		event,
		msg,
		&response,
	}
	channel.PushSignal(item)
	return response

}

func main(){
    globalChannel = NewChannel()
    globalChannel.onRequset()
    println(response)
}