/************************************************************************************
 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
 * All rights reserved.
 * Refer to LICENSE for terms and conditions of use.
 ***********************************************************************************/
//Petroaca - 
package vnsim.network.dsrc;


import java.io.ByteArrayInputStream;
import java.util.Random;

import java.util.ArrayList;

import vnsim.core.events.ReceiveEvent;
import vnsim.core.events.SendEvent;
import vnsim.map.object.Globals;



public class MAC80211
{
	private int ChannelState;
	
	private int RXState,TXState;
	
	private int currentTime;
	
	private DsrcFrame currentFrame;
	
	private static final double relError= 1E-12;
	
	//the timer which decides how many simulation times the station will wait until it will reschedule the packet
	private int backoffTimer;
	
	//the sinr threshold for the BPSK code rate
	private double SINRThreshold=Globals.SINRThresholdBPSK;
	
	private Random randBackoff;
	
	//contention window ; varies according to the transmission success or failure
	private int CWSafety,CWVehicleState,CW;
	
	//the EDCA mechanism
	//the safety Access Category in EDCA
	private ArrayList<SendEvent> ACSafety;
	
	//the vehicle state Access Category in EDCA
	private ArrayList<SendEvent> ACVehicleState;
	
	private double receptionRate;
	
	private int receivedOk;
	
	public MAC80211(int currentTime)
	{
		this.ChannelState=Globals.CCA_IDLE;
		
		this.RXState=Globals.RX_IDLE;
		this.TXState=Globals.TX_IDLE;
		
		this.currentTime=currentTime;
		this.currentFrame=new DsrcFrame();
		
		this.randBackoff=new Random();
		
		this.CWVehicleState=2;
		
		this.CWSafety=1;
		
		this.CW=0;
		
		this.backoffTimer=this.randBackoff.nextInt(this.CWSafety+1);
		
		/*
		this.CWVehicleState=7;
		this.ACSafety=new ArrayList<SendEvent>();
		this.ACVehicleState=new ArrayList<SendEvent>();
		*/
		
		this.receptionRate=0;
		this.receivedOk=0;
	}

	public int getChannelState()
	{
		return this.ChannelState;
	}
	
	public void setChannelState(int set)
	{
		this.ChannelState=set;
	}
	
	public byte[] recvFromPhysical(ReceiveEvent re,double sinr,int currentTime)
	{
		
		
		//first check SINR to see if frame is corrupted
		if(re.getSender()==null)
		{
			if(sinr<this.SINRThreshold)
			{
				Globals.DSRC_PACKETS_LOST_CORRUPTED++;
				return null;
			}
		}
		
		
		//CRC check and BER
		//should calculate the SINR and BER of the header of the frame in a different modulation than the rest of the frame
		//calculate PER 
		double preambleBits=Globals.DSRC_PREAMBLE_LENGTH*8,headerBits=Globals.DSRC_PHYHEADER_LENGHT*8,dataBits=0;
		
		ByteArrayInputStream byteStream = new ByteArrayInputStream(re.getMessage());
		
		dataBits=byteStream.available()*8;
		
		double per;
		if((per=calculatePER(sinr,preambleBits,headerBits,dataBits))>Globals.DSRC_PER_THRESHOLD)
		{
			//per checked ok
			//return data to application
			this.RXState=Globals.RX_RECV;
			Globals.DSRC_PACKETS_RECEIVED_OK++;
			this.receivedOk++;
			return re.getMessage();
		}
		//packet dropped due to bad per check
		
		Globals.DSRC_PACKETS_LOST_PER++;
		
		return null;
	}
	
	public byte[] sendToPhysical(byte[] message,int currentTime)
	{
		
		//DsrcFrame frame=new DsrcFrame();
		
		//check channel state ; employ backoff timer
		if(this.ChannelState==Globals.CCA_BUSY)
		{
			//channel busy ; pause backoff timer
			//this.setBackoffTimer(this.backoffTimer+1);
			
			//the reason for the faliure to send
			if(this.RXState!=Globals.RX_RECV)
				Globals.DSRC_PACKETS_SEND_FALIURE_RX++;
			else
				Globals.DSRC_PACKETS_SEND_FALIURE_NOISE++;
			
			if(this.TXState!=Globals.TX_RECV)
				this.TXState=Globals.TX_RECV;
			return null;
		}
		
		//EDCA scheduler - sets the CW to the respective value depending on the message priority
		this.EDCAScheduler(message[0]);
		//if(this.TXState==Globals.TX_IDLE)
		//{
			if(this.backoffTimer==0)
			{
				this.setBackoffTimer(this.randBackoff.nextInt(this.CW+1));
				this.TXState=Globals.TX_IDLE;
				
				return message;

			}
			else
			{
				this.backoffTimer--;
				this.TXState=Globals.TX_RECV;
				return null;
			}
					//}
		//return null;
	}
	
	public void refreshFrameTime(int currentTime)
	{
		if(currentTime-this.currentTime>=Globals.WIRELESS_TRANSMISSION_FRAMES)
		{
			this.RXState=Globals.RX_IDLE;
			this.ChannelState=Globals.CCA_IDLE;
			
			if(currentTime%4==0)
				this.receivedOk=0;
		}
		
		this.currentTime=currentTime;
		
	}
	
	public double calculatePER(double sinr,double preambleNbits,double headerNbits,double dataNbits)
	{
		double psr=1;
		
		psr*=calculateBER(sinr,preambleNbits,Globals.DSRC_DATA_RATE);
		psr*=calculateBER(sinr,headerNbits,Globals.DSRC_PCLP_RATE);
		psr*=calculateBER(sinr,dataNbits,Globals.DSRC_DATA_RATE);
		
		return 1-psr;
		
	}
	
	public double calculateBER(double sinr,double nbits,double dataRate)
	{
		double ber=BPSKBER(sinr,dataRate);
		
		double csr=Math.pow(1-ber, nbits);
		
		return csr;
	}
	
	public double BPSKBER(double sinr,double dataRate)
	{
		double EbNo=sinr * Globals.DSRC_SIGNAL_SPREAD/dataRate;
		
		double z=Math.sqrt(EbNo);
		
		double ber=0.5 * erfc(z);
		
		return ber;
	}
	
	public double erf(double x)
	{
		final double twoSqrtPi=2/Math.sqrt(Math.PI);
		
		if(Math.abs(x) > 2.2)
			return 1.0-erfc(x);
		
		double sum=x,term=x,xsqr=x*x;
		
		int j=1;
		
		do{
			term*= xsqr/j;
			sum-= term/(2*j+1);
			++j;
			term*= xsqr/j;
			sum+= term/(2*j+1);
			++j;
		} while (Math.abs(term/sum) > relError);
		
		return twoSqrtPi*sum;
		
	}
	
	public double erfc(double x)
	{
		final double oneSqrtPi=1/Math.sqrt(Math.PI);
		
		
		if(Math.abs(x) < 2.2)
			return 1.0-erf(x);
		
		if(x<0)
			return 2.0-erfc(-x);
		
		double a=1, b=x;                //last two convergent numerators
		double c=x, d=x*x+0.5;          //last two convergent denominators
		double q1, q2= b/d;             //last two convergents (a/c and b/d)
		double n= 1.0, t;
		
		do {
		t= a*n+b*x;
		a= b;
		b= t;
		t= c*n+d*x;
		c= d;
		d= t;
		n+= 0.5;
		q1= q2;
		q2= b/d;
		} while (Math.abs(q1-q2)/q2 > relError);
		
		return oneSqrtPi*Math.exp(-x*x)*q2;
	}
	
	public void setBackoffTimer(int set)
	{
		this.backoffTimer=(set>this.CWSafety)?this.CWSafety:set;
		
	}
	
	public int getBackoffTimer()
	{
		return this.backoffTimer;
	}
	
	public void recalculateCW(int totalPackets,int currentTime)
	{
		if(currentTime%4==0 && totalPackets!=0)
		{
			double aux=((double)this.receivedOk/totalPackets*100);
			
			if(aux-this.receptionRate>Globals.RECEPTION_RATE_THRESHOLD)
			{
				this.receptionRate=aux;
				this.CWSafety=(this.CWSafety==0)?0:this.CWSafety-1;
				this.CWVehicleState=(this.CWVehicleState==0)?0:this.CWVehicleState-1;
				return;
			}
			
			if(-(aux-this.receptionRate)>Globals.RECEPTION_RATE_THRESHOLD)
			{
				this.receptionRate=aux;
				this.CWSafety++;
				this.CWVehicleState++;
			}
		}
	}
	
	public void EDCAScheduler(int messageType)
	{
		//to be completed with other message types
		switch(messageType)
		{
		case Globals.PROT_EMERGENCY:
					this.CW=this.CWSafety;
					break;
		default:	this.CW=this.CWVehicleState;
					break;
		}
	}
}