package QUEUE

import (
	"strings"
	"sync"
)

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

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

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

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

// 出隊(duì)操作
// 需要考慮: 隊(duì)隊(duì)為空沒(méi)有數(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來(lái)避免內(nèi)存泄露
	q.front = (q.front + 1) % q.cap
	return data
}

// 循環(huán)隊(duì)列長(zhǎng)度計(jì)算，考慮哨兵空間
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()

	// 計(jì)算隊(duì)列中的有效元素?cái)?shù)量
	length := q.QueueLength()

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

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

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

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

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

package server

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

//隊(duì)列通道
type Channel struct {
    queue                  *MeetGo.CycleQueue
}

//隊(duì)列參數(shù)項(xiàng)
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)建隊(duì)列通道
func NewChannel() {
    channel.queue = QUEUE.NewCycleQueue(1000)
    go channel.handle()
    return
}

//處理隊(duì)列數(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)
}