#include "bitRingLib.h"
#include "stdLib.h"


BIT_RNG_ID bitRingCreate( int iBitNum )
{	
	BIT_RNG_ID  bitRingId;
	int         iBuffByteSize;
	
	if( iBitNum <= 0 )
	{
		printf( "[bitRingCreate]:the para is invalid\n" );
		return( 0 );
	}
	
	bitRingId                  = ( BIT_RNG_ID )malloc( sizeof( strBitRing ) );
	bitRingId->iReadOffset     = 0;
	bitRingId->iWriteOffset    = 0;
	bitRingId->enumBuffStatus  = BUFF_EMPTY;
	
	if( ( iBitNum % 8 ) == 0 )
	{
		iBuffByteSize = iBitNum / 8;
	}
	else
	{
		iBuffByteSize = ( 8 - ( iBitNum % 8 ) + iBitNum ) / 8;
	}
	
	bitRingId->iBufSize     = iBitNum;
	bitRingId->pcBuffStart  = ( char* )malloc( iBuffByteSize );
		
	return( bitRingId );
}
	

int bitRingDelete( BIT_RNG_ID bitRingId )
{
	if( bitRingId == NULL )
	{
		printf( "[bitRingDelete]:the para is invalid\n" );
		return( 0 );
	}
	
	free( bitRingId->pcBuffStart );
	free( ( char* )bitRingId );
	
	return( 1 );
}


static int bitRingBitCopy( unsigned char *pucDstByteBuff, int iDstByteBitIndex, 
                           unsigned char  usStrByte,      int iStrByteBitIndex )
{
	unsigned char  ucTempVariable1, ucTempVariable2;
	
	if( ( iDstByteBitIndex < 0 ) || ( iDstByteBitIndex > 7 ) || ( iStrByteBitIndex < 0 ) ||
	    ( iStrByteBitIndex > 7 ) || ( pucDstByteBuff == NULL ) ) 
	{
		printf( "[bitRingBitCopy]:the para is invalid\n" );
		return( 0 );
	}
	
	ucTempVariable1 = ( usStrByte       << iStrByteBitIndex  )   &  0x80;
	ucTempVariable2 = ( ~( 0x80         >> iDstByteBitIndex  ) ) & *pucDstByteBuff;
	*pucDstByteBuff = ( ucTempVariable1 >> iDstByteBitIndex  )   |  ucTempVariable2;
	
	return( 1 );
}


int bitRingFreeBits( BIT_RNG_ID bitRingId )
{
	int  iFreeRoom;
	
	if( bitRingId->enumBuffStatus == BUFF_EMPTY )
	{
		return( bitRingId->iBufSize );
	}
	else if( bitRingId->enumBuffStatus == BUFF_FULL )
	{
		return( 0 );
	}
    else if( bitRingId->enumBuffStatus == BUFF_NORMAL )
    {
	    iFreeRoom = bitRingId->iBufSize - ( ( bitRingId->iWriteOffset + bitRingId->iBufSize - bitRingId->iReadOffset ) 
		            % bitRingId->iBufSize );
		return( iFreeRoom );            
    }
    
}


int bitRingPut( BIT_RNG_ID bitRingId, unsigned char *pucDataBuff, int iDataBuffMaxLenth,
                int iPutDataBitNum )
{
	int        i;
	int        iRealPutBitNum, iFreeRoom, iCurrentPutBitIndex = 0;
	int        iStrDataByteIndex, iStrDataBitIndex;
	int        iDstDataByteIndex, iDstDataBitIndex;
	
	if( ( bitRingId == NULL ) || ( pucDataBuff == NULL ) || ( iDataBuffMaxLenth <= 0 ) ||
	    ( iPutDataBitNum <= 0 ) || ( iDataBuffMaxLenth * 8 < iPutDataBitNum ) )
	{
		printf( "[bitRingPut]:the para is invalid\n" );
		return( 0 );
	}
	if( bitRingId->enumBuffStatus == BUFF_FULL )
	{
		return( 0 );
	}
	
	iFreeRoom = bitRingFreeBits( bitRingId );
	if( iFreeRoom <= iPutDataBitNum )
	{
		iRealPutBitNum = iFreeRoom;
		bitRingId->enumBuffStatus = BUFF_FULL;
	}
	else
	{
		iRealPutBitNum = iPutDataBitNum;
	}
    /*printf( "[bitRingGet]:writeOffset is %d, readOffset is %d\n",bitRingId->iWriteOffset,bitRingId->iReadOffset);*/
	for( i = 0; i < iRealPutBitNum; i++ )
	{
        iStrDataByteIndex = iCurrentPutBitIndex / 8;
        iStrDataBitIndex  = iCurrentPutBitIndex - 8 * iStrDataByteIndex;
        iDstDataByteIndex = bitRingId->iWriteOffset / 8;
        iDstDataBitIndex  = bitRingId->iWriteOffset - 8 * iDstDataByteIndex;
        
		bitRingBitCopy( bitRingId->pcBuffStart + iDstDataByteIndex , iDstDataBitIndex,
		                pucDataBuff[ iStrDataByteIndex ], iStrDataBitIndex );
		iCurrentPutBitIndex++;
		bitRingId->iWriteOffset = ++( bitRingId->iWriteOffset ) % bitRingId->iBufSize;
    }
    
    if( bitRingId->enumBuffStatus == BUFF_EMPTY )
    {
    	bitRingId->enumBuffStatus = BUFF_NORMAL;
    }
    /*printf( "[bitRingGet]:writeOffset is %d, readOffset is %d\n",bitRingId->iWriteOffset,bitRingId->iReadOffset); */ 
    return( iRealPutBitNum );                     
}                      


int bitRingGet( BIT_RNG_ID bitRingId, unsigned char *pucDataBuff, int iDataBuffMaxLenth,
                int iGetDataBitNum )
{
	int        i;
	int        iRealGetBitNum, iUsedRoom, iCurrentGetBitIndex = 0;
	int        iStrDataByteIndex, iStrDataBitIndex;
	int        iDstDataByteIndex, iDstDataBitIndex;	

	if( ( bitRingId == NULL ) || ( pucDataBuff == NULL ) || ( iDataBuffMaxLenth <= 0 ) ||
	    ( iGetDataBitNum <= 0 ) || ( iDataBuffMaxLenth * 8 < iGetDataBitNum ) )	
	{
		printf( "[bitRingGet]:the para is invalid\n" );
		return( 0 );
	}
	if( bitRingId->enumBuffStatus == BUFF_EMPTY )
	{
		return( 0 );
	}

	iUsedRoom = bitRingId->iBufSize - bitRingFreeBits( bitRingId );
	if( iUsedRoom <= iGetDataBitNum )
	{
		iRealGetBitNum             = iUsedRoom;
		bitRingId->enumBuffStatus  = BUFF_EMPTY;
	}
	else
	{
		iRealGetBitNum = iGetDataBitNum;
	}
    /*printf( "[bitRingGet]:writeOffset is %d, readOffset is %d\n",bitRingId->iWriteOffset,bitRingId->iReadOffset);	*/
	for( i = 0; i < iRealGetBitNum; i++ )
	{
        iDstDataByteIndex = iCurrentGetBitIndex / 8;
        iDstDataBitIndex  = iCurrentGetBitIndex - 8 * iDstDataByteIndex;
        iStrDataByteIndex = bitRingId->iReadOffset / 8;
        iStrDataBitIndex  = bitRingId->iReadOffset - 8 * iStrDataByteIndex;
        
		bitRingBitCopy( &pucDataBuff[ iDstDataByteIndex ], iDstDataBitIndex, 
		                bitRingId->pcBuffStart[ iStrDataByteIndex ], iStrDataBitIndex );
		iCurrentGetBitIndex++;
		bitRingId->iReadOffset = ++( bitRingId->iReadOffset ) % bitRingId->iBufSize;
    }
    
    if( bitRingId->enumBuffStatus == BUFF_FULL )
    {
    	bitRingId->enumBuffStatus = BUFF_NORMAL;
    }
printf( "[bitRingGet]:writeOffset is %d, readOffset is %d\n",bitRingId->iWriteOffset,bitRingId->iReadOffset);    	
	return( iCurrentGetBitIndex );
}


int bitRingFlush( BIT_RNG_ID bitRingId )
{
	if( bitRingId == NULL )
	{
		printf( "[bitRingFlush]:the para is invalid\n" );
		return( 0 );
	}
	
	bitRingId->enumBuffStatus   = BUFF_EMPTY;
	bitRingId->iReadOffset      = 0;
	bitRingId->iWriteOffset     = 0;
	
	return( 1 );
}


int bitRingIsEmpty( BIT_RNG_ID bitRingId )
{
	if( bitRingId->enumBuffStatus == BUFF_EMPTY )
	{
		return( 1 );
	}
	return( 0 );
}


int bitRingIsFull( BIT_RNG_ID bitRingId )
{
	if( bitRingId->enumBuffStatus == BUFF_FULL )
	{
		return( 1 );
	}
	return( 0 );
}