using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.Protobuf.Compilers
{
    /// <summary>
    /// Represents a protobuf C# Compiler.
    /// </summary>
    /// <seealso cref="Tango.Protobuf.ProtoCompiler" />
    public class CSharpCompiler : ProtoCompiler
    {
        /// <summary>
        /// Gets t
/*
 * CommunicationTask.c
 *
 *  Created on: 8 ����� 2018
 *      Author: shlomo
 */

#include "include.h"
#include "drivers/Uart_Comm/uart.h"
#include "communicationTask.h"
#include <Container.h>
#include "delay.h"
#include "modules/Diagnostics/Diagnostics.h"


Mailbox_Handle          CommunicationRxMsgQ = NULL;
Mailbox_Handle          CommunicationTxMsgQ = NULL;
#define COMMUNICATION_NUM_MSGS 50
typedef struct CommRxMessage{
    //uint16_t messageId;
    uint16_t msgSize;
    uint32_t BuffId;
}CommRxMessageStruc;
typedef struct CommTxMessage{
    //uint16_t messageId;
    uint16_t msgSize;
    char *Buff;
}CommTxMessageStruc;

int CommType = isUART;

struct serialBuffer {
  char *buffer;
  size_t used;
  size_t size;
} typedef SerialBuffer;
#define SHORT_BUFFER_SIZE 200
char CommShortRxBuffer[10][SHORT_BUFFER_SIZE];
char CommRxBuffer[COMM_MAX_BUFFER_SIZE];
SerialBuffer inBuffer[11];
bool SerialBufferUsed[11] = {false,false,false,false,false,false,false,false,false,false,false};
uint32_t initArray(size_t initialSize)
{
  if (initialSize >= COMM_MAX_BUFFER_SIZE) return 0;
  if (initialSize > SHORT_BUFFER_SIZE)
  {
      if (SerialBufferUsed[10] == true)
      {
          return 0xFF;
      }
      else
      {
          SerialBufferUsed[10] = true;
          inBuffer[10].buffer = CommRxBuffer;
          inBuffer[10].used = 0;
          inBuffer[10].size = initialSize;
          return 10;
      }
  }
  else
  {
      int i;
      for (i = 0; i < 10; i++)
      {
          if (SerialBufferUsed[i] == false)
              break;
      }
      if (i == 10) return 0xFF;
      else
      {
          SerialBufferUsed[i] = true;
          inBuffer[i].buffer = &CommShortRxBuffer[i];
          inBuffer[i].used = 0;
          inBuffer[i].size = initialSize;
          return i;
      }
  }
  /*SerialBuffer *a = &inBuffer;
  a->buffer = CommRxBuffer;
  a->used = 0;
  a->size = initialSize;
  return initialSize;*/
}

void insertArray(uint32_t buffer,char element)
{
    SerialBuffer *a = &inBuffer[buffer];
  // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
  // Therefore a->used can go up to a->size
  a->buffer[a->used++] = element;
}

void freeArray(uint32_t buffer)
{
     SerialBufferUsed[buffer] = false;
}

uint32_t CommunicationTaskInit(void)
{
    USBCDCD_init();
    Init_U0();

    return OK;
}
uint32_t CommTxMsgCounter = 0;
uint32_t CommRxMsgCounter = 0;
uint32_t CommunicationTaskMessageReceived(uint32_t buffer,uint16_t msgSize)
{
    CommRxMessageStruc CommRxMessage;
    CommRxMsgCounter++;

    //CommRxMessage.messageId = 1;
    CommRxMessage.msgSize = msgSize;
    CommRxMessage.BuffId = buffer;
    if (CommunicationRxMsgQ != NULL)
        /*retcode =*/ Mailbox_post(CommunicationRxMsgQ , &CommRxMessage, BIOS_NO_WAIT);

    return OK;

}

/******************************************************************************
 *  ======== communicationTask ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this communication task is created statically in system initialization, in blocking mode
 *  over one of the chosen ommunication methods (USB or Blutooth).
 ******************************************************************************/
uint32_t cLength[51] = {0};
byte cindex = 0;
void communicationTask(UArg arg0, UArg arg1)
{

    CommRxMessageStruc CommRxMessage;


    //ui32RxCount = 0;
    CommunicationRxMsgQ = Mailbox_create(sizeof(CommRxMessageStruc), 4, NULL,NULL);

    /* Block while the device is NOT connected to the USB */
//    Semaphore_pend(initConnectionSem, BIOS_WAIT_FOREVER);

    while(1)
    {
        Mailbox_pend(CommunicationRxMsgQ , &CommRxMessage, BIOS_WAIT_FOREVER);
        /*switch (CommRxMessage.messageId)
        {
            case 1:*/
            cLength[cindex] = CommRxMessage.msgSize;
            if (cindex++>=50)
            cindex = 0;
            receive_callback(inBuffer[CommRxMessage.BuffId].buffer,inBuffer[CommRxMessage.BuffId].used);
            freeArray(CommRxMessage.BuffId);
       /*         break;
            default:
                break;
        }*/
    }

}
int UnSentMessages=0, deliveryfailure = 0;
bool CommunicationTaskSendMessage(char* buffer,size_t length)
{
    CommTxMessageStruc CommTxMessage;
    CommTxMsgCounter++;
    bool retcode = true;

    //CommTxMessage.messageId = 1;
    CommTxMessage.msgSize = length;
    CommTxMessage.Buff = buffer;
    UnSentMessages++;
    if (CommunicationTxMsgQ != NULL)
        retcode = Mailbox_post(CommunicationTxMsgQ , &CommTxMessage, BIOS_NO_WAIT);
    if (retcode == false)
    {
        my_free(buffer);
        deliveryfailure++;
//        CommunicationMailboxFlush();
    }


    return retcode;
}
int memoryrelease = 0;
void CommunicationMailboxFlush(void)
{
    int i;
    CommTxMessageStruc CommTxMessage;
    for (i=0;i<COMMUNICATION_NUM_MSGS;i++)
    {
        if (Mailbox_pend(CommunicationTxMsgQ , &CommTxMessage, BIOS_NO_WAIT))
        {
            UnSentMessages--;
            LOG_ERROR(CommTxMessage.msgSize,"Flushing CommTxMessage");
            my_free(CommTxMessage.Buff);
            memoryrelease+=CommTxMessage.msgSize;
        }
    }
}
int32_t SetCommunicationPath(bool UARTorUSB)
{
    CommType = UARTorUSB;
    return OK;
}

/******************************************************************************
 *  ======== communicationTask ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this communication task is created statically in system initialization, in blocking mode
 *  over one of the chosen Communication methods (USB or Bluetooth).
 ******************************************************************************/
void communicationTxTask(UArg arg0, UArg arg1)
{

    CommTxMessageStruc CommTxMessage;
    //initArray(1);
    CommunicationTxMsgQ = Mailbox_create(sizeof(CommTxMessageStruc), COMMUNICATION_NUM_MSGS, NULL,NULL);

    while(1)
    {
        Mailbox_pend(CommunicationTxMsgQ , &CommTxMessage, BIOS_WAIT_FOREVER);
        UnSentMessages--;
        if ( CommTxMessage.msgSize > COMM_MAX_BUFFER_SIZE)
        {
            LOG_ERROR(CommTxMessage.msgSize , "message too long");
        }
        else
        {
                if (CommType == isUSB)
                    USBCDCD_sendData(CommTxMessage.Buff, CommTxMessage.msgSize,10);
                else if (CommType == isUART)
                    Uart_Tx(CommTxMessage.Buff, CommTxMessage.msgSize);
        }
        if (diagnosticscontainer_buffer == CommTxMessage.Buff)
            diagnosticscontainer_buffer = 0;
        my_free(CommTxMessage.Buff);
        //delayms(1); //wait 5 milliseconds between messages
    }

}