package control

import (
	"errors"
	"fmt"
	"log"
	"os"
	"strconv"
	"sync"
	"time"

	"gerrit.o-ran-sc.org/r/ric-app/rc/protocol/grpc/ricmsgcommrpc/rc"
	"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
)

var (
	gControlData               *Control
	gChan_RicControlReq_handle = make(chan *rc.RicControlGrpcReq, 2000) //Make it configurable
)

func NewControl() Control {

	file := "/opt/rc.log"
	logFile, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
	if err != nil {
		panic(err)
	}
	log.SetOutput(logFile)
	log.SetPrefix("[qSkipTool]")
	log.SetFlags(log.LstdFlags | log.Lshortfile | log.LUTC)
	logLevel := xapp.Config.GetInt("controls.logLevel")
	xapp.Logger.SetLevel(logLevel)

	xapp.Logger.Debug("GRPC Server Port = %v ", xapp.Config.GetString("controls.ricHOControlgRpcServerPort"))
	xapp.Logger.Debug("Log Level = %d ", xapp.Config.GetInt("controls.logLevel"))

	go StartgRPCRCControlCommServerRoutine()
	xapp.Logger.Debug("StartgRPCRCControlCommServerRoutine done")

	//To Handle RIC Control Message
	go StartHandleControlReqRoutine()

	return Control{5,
		make(chan *xapp.RMRParams, 1000), //Make it configurable
		make(map[int]bool),
		&sync.Mutex{},
		0}
}

func ReadyCB(i interface{}) {
	gControlData = i.(*Control)
	go controlLoop()
}

func (aControlData *Control) Run() {
	xapp.SetReadyCB(ReadyCB, aControlData)
	xapp.Run(aControlData)
}

func (aControlData *Control) Consume(rp *xapp.RMRParams) (err error) {
	gControlData.rcChan <- rp
	return
}

func (aControlData *Control) rmrSend(params *xapp.RMRParams) (err error) {
	if !xapp.Rmr.Send(params, false) {
		err = errors.New("rmr.Send() failed")
		xapp.Logger.Info("Failed to rmrSend to %v", err)
		log.Printf("Failed to rmrSend to %v", err)
	}
	return
}

func (aControlData *Control) rmrReplyToSender(params *xapp.RMRParams) (err error) {
	if !xapp.Rmr.Send(params, true) {
		err = errors.New("rmr.Send() failed")
		xapp.Logger.Error("Failed to rmrReplyToSender to %v", err)
		log.Printf("Failed to rmrReplyToSender to %v", err)
	}
	return
}

func controlLoop() {
	for {
		msg := <-gControlData.rcChan
		xapp.Logger.Debug("Received message type: %d", msg.Mtype)
		log.Printf("Received message type: %d", msg.Mtype)
		switch msg.Mtype {
		case 12041:
			go HandleControlResponse(msg)
		case 12042:
			go HandleControlFailure(msg)
		default:
			err := errors.New("Message Type " + strconv.Itoa(msg.Mtype) + " is discarded")
			xapp.Logger.Error("Unknown message type: %v", err)
			log.Printf("Unknown message type: %v", err)
		}
	}
}

func StartHandleControlReqRoutine() {

	log.Printf("Starting Go Routine for Handling GRPC RIC Control msg ")
	xapp.Logger.Info("Starting Go Routine for Handling GRPC RIC Control msg ")
	for {
		HandlegRPCRICControlMsgReq(<-gChan_RicControlReq_handle)
	}
	xapp.Logger.Debug("StartHandleControlReqRoutine Done")
}

func HandlegRPCRICControlMsgReq(aPtrRicControlGrpcReq *rc.RicControlGrpcReq) {

	xapp.Logger.Debug("HandlegRPCRICControlMsgReq :%v", *aPtrRicControlGrpcReq)
	lRicHoControlMsg := RicHoControlMsg{}
	lRicHoControlMsg.RicControlGrpcReqPtr = aPtrRicControlGrpcReq

	lUEID := lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID
	xapp.Logger.Debug("HandlegRPCRICControlMsgReq UEID = %v ", lUEID)
	//Mandatory parameters validation
	if lRicHoControlMsg.RicControlGrpcReqPtr.E2NodeID == "" ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID == "" ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.AmfUENGAPID < 0 ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.Guami.PLMNIdentity == "" ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.Guami.AMFRegionID == "" ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.Guami.AMFSetID == "" ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.Guami.AMFPointer == "" ||
		len(lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.GNBCUUEF1APID) == 0 ||
		len(lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID.GnbUEID.GNBCUCPUEE1APID) == 0 ||
		lRicHoControlMsg.RicControlGrpcReqPtr.PlmnID == "" ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlActionId < 0 ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlStyle < 0 ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal < 0 ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID < 0 ||
		lRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId < 0 {
		xapp.Logger.Error("Mandaroty parameters missing, dont send control request ")
		return
	}

	lRicHoControlMsg.GetSequenceNumber()

	go lRicHoControlMsg.SendRicControlRequest(lRicHoControlMsg.GetSequenceNumber())

	return
}

func (aRicHoControlMsg *RicHoControlMsg) GetSequenceNumber() int {

	//Incrementing the RIC Requestor Instance Id to make the request unique and traceable.
	gControlData.eventRicControlReqExpiredMu.Lock()
	gControlData.ricRequestInstanceID = gControlData.ricRequestInstanceID + 1
	gControlData.eventRicControlReqExpiredMu.Unlock()

	return gControlData.ricRequestInstanceID
}

func (aRicHoControlMsg *RicHoControlMsg) setEventRicControlCreateExpiredTimer(aSeqNum int) {

	gControlData.eventRicControlReqExpiredMu.Lock()
	gControlData.eventRicControlReqExpiredMap[aSeqNum] = false
	gControlData.eventRicControlReqExpiredMu.Unlock()
	controlAckTimer := xapp.Config.GetInt("controls.controlAckTimer")
	xapp.Logger.Debug("configured controlAckTimer = %d and controlAckTimer = %d ", xapp.Config.GetInt("controls.controlAckTimer"),controlAckTimer)

	timer := time.NewTimer(time.Duration(controlAckTimer) * time.Second)
	go func(t *time.Timer) {
		defer t.Stop()
		xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: Waiting for RIC_CONTROL_RESP...", aSeqNum)
		log.Printf("RIC_CONTROL_REQ[%s]: Waiting for RIC_CONTROL_RESP...", aSeqNum)
		for {
			select {
			case <-t.C:
				gControlData.eventRicControlReqExpiredMu.Lock()
				isResponsed := gControlData.eventRicControlReqExpiredMap[aSeqNum]
				delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)
				gControlData.eventRicControlReqExpiredMu.Unlock()
				if !isResponsed {
					xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: RIC Event Create Timer experied!", aSeqNum)
					log.Printf("RIC_CONTROL_REQ[%s]: RIC Event Create Timer experied!", aSeqNum)
					//Send ErrorIndication message on Timeout
					return
				}
			default:
				gControlData.eventRicControlReqExpiredMu.Lock()
				flag := gControlData.eventRicControlReqExpiredMap[aSeqNum]
				if flag {
					delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)
					gControlData.eventRicControlReqExpiredMu.Unlock()
					xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: RIC Event Create Timer canceled!", aSeqNum)
					log.Printf("RIC_CONTROL_REQ[%s]: RIC Event Create Timer canceled!", aSeqNum)
					return
				} else {
					gControlData.eventRicControlReqExpiredMu.Unlock()
				}
			}
			time.Sleep(100 * time.Millisecond)
		}
	}(timer)
}
func (aRicHoControlMsg *RicHoControlMsg) SendRicControlRequest(aRequestSN int) (err error) {
	var e2ap *E2ap
	var e2sm *E2sm

	xapp.Logger.Info("SendRicControlRequest Enter for RanName = %s", aRicHoControlMsg.RicControlGrpcReqPtr.RanName)

	if aRicHoControlMsg.RicControlGrpcReqPtr == nil {
		return err
	}

	var lRicControlStyleType int64 = aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlStyle
	var lRicControlActionID int64 = aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlActionId
	lUEID := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID

	var ueId_data UEid

	xapp.Logger.Debug("UEID:%v, ueId_data strct :%v", aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID,
		ueId_data)
	ueId_data.amf_UE_NGAP_Id = lUEID.GnbUEID.AmfUENGAPID
	ueId_data.pLMNIdentitybuf = lUEID.GnbUEID.Guami.PLMNIdentity
        ueId_data.aMFRegionIDbuf = lUEID.GnbUEID.Guami.AMFRegionID
        ueId_data.aMFSetIDbuf = lUEID.GnbUEID.Guami.AMFSetID
        ueId_data.aMFPointerbuf = lUEID.GnbUEID.Guami.AMFPointer
        ueId_data.F1AP_id = lUEID.GnbUEID.GNBCUUEF1APID
        ueId_data.E1AP_id = lUEID.GnbUEID.GNBCUCPUEE1APID

	var lRicControlHeader []byte = make([]byte, 1024) //Check the Size
	lRicControlHeaderEncoded, err := e2sm.SetRicControlHeader(lRicControlHeader, &ueId_data, lRicControlStyleType, lRicControlActionID)
	if err != nil {
		xapp.Logger.Error("SetRicControlHeader Failed: %v, UEID:%v", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
		log.Printf("SetRicControlHeader Failed: %v, UEID:%v", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
		return err
	} else {
		xapp.Logger.Info("SetRicControlHeader is success: %x", lRicControlHeaderEncoded)
		fmt.Fprintf(os.Stderr, "Encoded RIC Control Header PDU:\n")
		for i := 0; i < len(lRicControlHeaderEncoded); i++ {
			fmt.Fprintf(os.Stderr, " %02x", lRicControlHeaderEncoded[i])
		}
		fmt.Fprintf(os.Stderr, "\n")
	}
	var lTargetPrimaryCell int64 = RIC_CONTROL_TARGET_PRIMARY_CELL
	var lTargetCell int64 = RIC_CONTROL_TARGET_CELL
	var lNrCGIOrECGI int64 = RIC_CONTROL_CGI_TYPE

	lNrOrEUtraCellType := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal
	lTargetCellVal := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID
	lTargetCellValBuf := []byte(lTargetCellVal)
	//lNRPlmnId := []byte(aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID.PlmnID)
        //lNRCellId := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID.NRCellID


	var lRicControlMessage []byte = make([]byte, 1024)
	lRicControlMessageEncoded, err := e2sm.SetRicControlMessage(lRicControlMessage, lTargetPrimaryCell, lTargetCell, lNrCGIOrECGI, int64(lNrOrEUtraCellType), lTargetCellValBuf)
	if err != nil {
		xapp.Logger.Error("SetRicControlMessage Failed: %v, UEID:%v", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
		log.Printf("SetRicControlMessage Failed: %v, UEID:%v", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
		return err
	} else {
		xapp.Logger.Debug("SetRicControlMessage is success: %x", lRicControlMessageEncoded)
		fmt.Fprintf(os.Stderr, "Encoded RIC Control Message PDU:\n")
		for i := 0; i < len(lRicControlMessageEncoded); i++ {
			fmt.Fprintf(os.Stderr, " %02x", lRicControlMessageEncoded[i])
		}
		fmt.Fprintf(os.Stderr, "\n")
	}

	lParams := &xapp.RMRParams{}
	lParams.Mtype = 12040 //RIC_CONTROL_REQ
	lParams.SubId = -1

	var lRequestorId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID)
	var lFuncId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId)

	lParams.Payload = make([]byte, 2048)
	lParams.Payload, err = e2ap.SetRicControlRequestPayload(lParams.Payload, lRequestorId, uint16(aRequestSN), lFuncId,
		lRicControlHeaderEncoded, lRicControlMessageEncoded)
	if err != nil {
		xapp.Logger.Error("SetRicControlRequestPayload Failed: %v, UEID:%v", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
		log.Printf("SetRicControlRequestPayload Failed: %v, UEID:%v", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
		return err
	} else {

		xapp.Logger.Debug("Encoding RicControlRequestPayload is success. UEID: %v, Payload: %x", lUEID, lParams.Payload)
		fmt.Fprintf(os.Stderr, "Encoded RIC Control Req PDU:\n")
		for i := 0; i < len(lParams.Payload); i++ {
			fmt.Fprintf(os.Stderr, " %02x", lParams.Payload[i])
		}
		fmt.Fprintf(os.Stderr, "\n")
	}
	lParams.PayloadLen = len(lParams.Payload)
	valEnbId := aRicHoControlMsg.RicControlGrpcReqPtr.E2NodeID
	valRanName := aRicHoControlMsg.RicControlGrpcReqPtr.RanName
	valPlmnId := aRicHoControlMsg.RicControlGrpcReqPtr.PlmnID
	lParams.Meid = &xapp.RMRMeid{PlmnID: valPlmnId, EnbID: valEnbId, RanName: valRanName}

	xapp.Logger.Debug("The RIC Control RMR message to be sent is with MsgType:%d  SubId=%d, lParams.Meid: %v, UEID: %v", lParams.Mtype, lParams.SubId, lParams.Meid, lUEID)

	xapp.Logger.Debug("Sending RIC Control message to RanName: %s, UEID: %v  ", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)
	
	xapp.Logger.Info("lParams %v ",lParams)
	err = gControlData.rmrSend(lParams)
	if err != nil {
		xapp.Logger.Error("Failed to send RIC_CONTROL_REQ: %v", err)
		log.Printf("Failed to send RIC_CONTROL_REQ: %v", err)
		xapp.Logger.Info("Failed to send RIC_CONTROL_REQ: %v", err)
		return err
	}

	xapp.Logger.Info("Sending RIC Control message to RanName: %s, UEID: %v  Success", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)
	//Start Timer Operation.
	aRicHoControlMsg.setEventRicControlCreateExpiredTimer(aRequestSN) //TODO check if this is required as we are not expecting Control ACK

	return nil
}

func HandleControlResponse(params *xapp.RMRParams) (err error) {

	var e2ap *E2ap
        var e2sm *E2sm
	xapp.Logger.Debug("The SubId in RIC_CONTROL_RESP is %d", params.SubId)
	log.Printf("The SubId in RIC_CONTROL_RESP is %d", params.SubId)



	//Decode the RIC Control Ack message
	controlAck, err := e2ap.GetControlAckMsg(params.Payload)
	if err != nil {
		xapp.Logger.Error("Failed to decode RIC Control Ack: %v", err)
                log.Println("Failed to decode RIC Control Ack: %v", err)
                return
	}
	log.Println("E2ap RIC RIC Control Ack message decoded \n")
	xapp.Logger.Info("E2ap RIC RIC Control Ack message decoded \n")
	gControlData.eventRicControlReqExpiredMu.Lock()
        _,ok := gControlData.eventRicControlReqExpiredMap[int(controlAck.InstanceId)]
        if !ok {
                gControlData.eventRicControlReqExpiredMu.Unlock()
                xapp.Logger.Debug("RIC_CONTROL_REQ has been deleted!")
                log.Printf("RIC_CONTROL_REQ has been deleted!")
                return nil
        } else {
                gControlData.eventRicControlReqExpiredMap[int(controlAck.InstanceId)] = true
		gControlData.eventRicControlReqExpiredMu.Unlock()
        }

	controlOutcome, err := e2sm.GetControlOutcome(controlAck.ControlOutcome)
        if err != nil {
		xapp.Logger.Error("Failed to decode RIC Control Outcome: %v", err)
                log.Println("Failed to decode RIC Control Outcome: %v", err)
                return
        }
        log.Println("E2SM-RC RIC Control Outcome  decoded \n",controlOutcome)
        xapp.Logger.Info("E2SM-RC RIC Control Outcome  decoded \n",controlOutcome)



	return nil
}

func HandleControlFailure(params *xapp.RMRParams) (err error) {

	var e2ap *E2ap

	xapp.Logger.Debug("The SubId in RIC_CONTROL_FAILURE is %d", params.SubId)
	log.Printf("The SubId in RIC_CONTROL_FAILURE is %d", params.SubId)

	controlAck, err := e2ap.GetControlFailureMsg(params.Payload)
	if err != nil {
                xapp.Logger.Debug("Failed to decode RIC Control message: %v", err)
                log.Println("Failed to decode RIC Control Ack: %v", err)
                return
        }
        log.Println("E2ap RIC  Control Ack message decoded \n")
        xapp.Logger.Debug("E2ap RIC Control Ack message decoded \n")

        gControlData.eventRicControlReqExpiredMu.Lock()
        _, ok := gControlData.eventRicControlReqExpiredMap[int(controlAck.InstanceId)]
        if !ok {
                gControlData.eventRicControlReqExpiredMu.Unlock()
                xapp.Logger.Debug("RIC_CONTROL_REQ has been deleted!")
                log.Printf("RIC_CONTROL_REQ has been deleted!")
                return nil
        } else {
                gControlData.eventRicControlReqExpiredMap[int(controlAck.InstanceId)] = true
                gControlData.eventRicControlReqExpiredMu.Unlock()
        }
	return nil
}