using System;
using System.Text;
using System.IO;
using System.Linq;
using System.Drawing;
using System.Diagnostics;
using System.Windows.Forms;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Tango.PMR.Stubs;
using Tango.Stubs;
//--------------------------------------------------------------------------------

const  int LTFU_UNDER_TEST=12;
//---------------------------

string [,] Units_status_LTFU = new string[LTFU_UNDER_TEST,2]	{ 
												{"LS_LLOADMOTOR_Up","Not Test"},	//0
												{"LS_LLOADMOTOR_DOWN","Not Test"},	//1
												{"LLOADING_Motor","Not Test"},		//2
												{"LDRIVING_Motor","Not Test"},		//3
												{"LS_LDANCER_Left_DOWN","Not Test"},	//4
												{"LS_LDANCER_Left_UP","Not Test"},		//5
												{"LDANCER_Left_Motor","Not Test"},		//6
												{"LDANCER_Left_ROTENC","Not Test"},		//7
												{"LDANCER_Right_ROTENC","Not Test"},	//8
												{"LS_LDANCER_Right_DOWN","Not Test"},	//9
												{"LS_LDANCER_Right_UP","Not Test"},		//10
												{"LDANCER_Right_Motor","Not Test"},		//11

											};
//-----------------------------------------------------
//--------------------------------------------------------------------------------


public Task<decimal> LTFU_test( Action<string> settext, CancellationToken cancellationToken, string SN, string Location)
{
	int no_of_test=12;

	Task<decimal> task = null;
    // Start a task and return it
    task = Task.Run(() =>
    {
 
	stubManager.Write("S/N:" +SN+ "\n");
	stubManager.Write("Location:" +Location+ "\n");

	copy_table (no_of_test,Units_status_LTFU);
	
	settext("Test LLOADING LTFU");
	Test_LLOADING_LTFU();
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LLOADING_Motor, 3);					//hold LRoading high z
	delay(100);
	Motor_SetParam(F1_MOTO_LLOADING_TX1,F1_MOTO_LLOADING_TX0,0x0a,0x14000000);							//set kval ran to 0x14,0.65A

	settext("Test LDRIVING LTFU");
	Test_LDRIVING_LTFU();

	settext("Test DANCER LTFU");

no_of_test=Test_DANCER_LTFU();
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LDANCER1_Motor, 3);					//hold Lloading high z

	Status=write_to_file(SN,Location,no_of_test,"LTFU");

	settext("End Test");
	
	decimal result = 0;
		
        return result;
    });
    return task;
}


 //------------------------------------  
int Test_LLOADING_LTFU()
{
	int	temp=1; 
	int counter;
	
	Motor_SetParam(F1_MOTO_LLOADING_TX1,F1_MOTO_LLOADING_TX0,0x0a,0x2c000000);							//set kval ran to 0x2c- 1.3A
	delay(100);
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LLOADING_Motor, false,200);				//move Rloading down
	delay(3000);
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LLOADING_Motor, 3);					//hold Rloading high z
	delay(1000);
//------------------------------------------ check  F1_LS_LLOADMOTOR_UP------------------------------------------------

	var response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//read LS
	if ((response.Value & F1_LS_LLOADMOTOR_UP) !=F1_LS_LLOADMOTOR_UP )									//if LS_RLOADMOTOR_UP is up then error
	{	
		DialogResult result = MessageBox.Show("Did LLOADIN MOTOR Move?", "Warning",MessageBoxButtons.YesNo);
	if(result == DialogResult.Yes)
		{
		Units_status[0,1]="Fail";
		stubManager.Write("LS_LLOADMOTOR_UP\tFail\n");	
		return 0;
		}
	else 
		{
			Units_status[2,1]="Fail";
			stubManager.Write("LLOADMOTOR\tFail\n");
			return 0;
		}
	}	
//----------------------------------------- mov LLOADING up -------------------------------------------------
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LLOADING_Motor,true,300);				//move Lloading up
	counter =0;
	while ( counter < 200)
	{
		counter = counter + 1;
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//if LS_LLOADMOTOR_UP is up then move down
		if ((response.Value & F1_LS_LLOADMOTOR_UP) != F1_LS_LLOADMOTOR_UP  )
			counter=250;
		
			delay(100);	
	}
		stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LLOADING_Motor, 3);					//hold Lloading high z

	if (counter == 200) 								
	{	
		Units_status[0,1]="Fail";
		stubManager.Write("LS_LLOADMOTOR_UP\tFail\n");	
		return 0;
	}
	DialogResult result1 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	if(result1 == DialogResult.No)
		{
			Units_status[0,1]="Fail";
			stubManager.Write("LS_LLOADMOTOR_UP Not calibrate\n");
			return 0;
		}
	Units_status[0,1]="Pass";
	Units_status[2,1]="Pass";
	
//------------------------------------------ check  F1_LS_LLOADMOTOR_DN------------------------------------------------
		
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);		//read LS
	
	if ((response.Value & F1_LS_LLOADMOTOR_DN) !=F1_LS_LLOADMOTOR_DN )										//if LS_LLOADMOTOR_DN is up then error
	{	
		Units_status[1,1]="Fail";
		stubManager.Write("LS_LLOADMOTOR_DN\tFail\n");
		return 0;
	}
//------------------------------------------ mov LLOADING dn ------------------------------------------------

	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LLOADING_Motor, false,300);				//move Lloading down
	counter =0;
	while ( counter < 200)
	{
		counter = counter + 1;
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//if LS_LLOADMOTOR_UP is up then move down
		if ((response.Value & F1_LS_LLOADMOTOR_DN) != F1_LS_LLOADMOTOR_DN  )
			counter=250;	
			
			delay(100);	
	}
	
		if (counter == 200) 								
	{	
		Units_status[1,1]="Fail";
		stubManager.Write("LS_LLOADMOTOR_DN\tFail\n");	
		return 0;
	}
		stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LLOADING_Motor, 3);					//hold Lloading high z
		
	DialogResult result4 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	if(result4 == DialogResult.No)
		{
			Units_status[1,1]="Fail";
			stubManager.Write("LS_LLOADMOTOR_DN Not calibrate\n");
			return 0;
		}
	Units_status[1,1]="Pass";
		stubManager.Write("LLOADMOTOR\tPass\n");
	
		stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LLOADING_Motor, false,200);				//move Lloading down
			delay(4000);	
		stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LLOADING_Motor, 3);					//hold Lloading high z

	return 1 ;

}	


Int32 ReadEncoder(int i)
{
	Int32 temp;
	
	if (i==1)			//LDANCER1_ROTENC == LTFU Danser Right
		{
			stubManager.Run<StubFpgaWriteRegResponse>("StubFpgaWriteRegRequest" ,F1_LDANCER1_ROTENC_TX, 0x0000);		//triggers a TX transmission

			var response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LDANCER1_ROTENC_LSB);
			var response1 = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LDANCER1_ROTENC_MSB);		 
		
			temp =  Convert.ToInt32 (((((response1.Value <<16) + 	response.Value)>>10 ) & 0x3fff));
	

			return temp;
		}
								//LDANCER2_ROTENC == LTFU Danser Left
		
			stubManager.Run<StubFpgaWriteRegResponse>("StubFpgaWriteRegRequest" ,F1_LDANCER2_ROTENC_TX, 0x0000);		//triggers a TX transmission
			var response2 = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LDANCER2_ROTENC_LSB);
			var response3 = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LDANCER2_ROTENC_MSB);		 
		
			temp =  Convert.ToInt32 (((((response3.Value <<16) + 	response2.Value)>>10 ) & 0x3fff));
	

			return temp;
}
//--------------------------------------------------------------------------------
int Test_DANCER_LTFU()
{
	int counter;
	Int32 temp_left_before;
	Int32 temp_left_after;
	Int32 temp_right_before;
	Int32 temp_right_after;
	
	
//------------------------------------------ check  F1_LS_LDANCER1_DN  ------------------------------------------------
	MessageBox.Show("Make sure LDANCERs Down");
	var response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//read LS
	
	if ((response.Value & F1_LS_LDANCER1_UP) !=F1_LS_LDANCER1_UP )								//if F1_LS_LDANCER1_UP is up then error
	{	
		Units_status[5,1]="Fail";
		stubManager.Write("LS_LDANCER_Left_UP\tFail\n");	
		return 12;
	}
//----------------------------------------- check F1_LS_LDANCER1_UP -------------------------------------------------
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LDANCER1_Motor,false,450);				//move Lloading up
	counter =0;
	while ( counter < 300)
	{
		counter = counter + 1;
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//if F1_LS_LDANCER1_UP is up then move down
		if ((response.Value & F1_LS_LDANCER1_UP) != F1_LS_LDANCER1_UP  )
			counter=350;
		
			delay(100);	
	}
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LDANCER1_Motor, 3);					//hold Ldancer high z
		if (counter == 300) 								
	{	
		Units_status[5,1]="Fail";
		stubManager.Write("LS_LDANCER_Left_UP\tFail\n");	
		return 12;
	}

	 response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//read LS
	if ((response.Value & F1_LS_LDANCER1_DN) !=F1_LS_LDANCER1_DN )								//if F1_LS_LDANCER1_DN is up then error
	{	
		Units_status[4,1]="Fail";
		stubManager.Write("LS_LDANCER_Left_DN\tFail\n");	
		return 12;
	}

	DialogResult result5= MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	
	if(result5== DialogResult.No)
		{
			Units_status[5,1]="Fail";
			stubManager.Write("LS_LDANCER_Left_UP Not calibrate\n");
			return 12;
		}
	
	Units_status[5,1]="Pass";
	stubManager.Write("LS_LDANCER_Left_UP\tPass\n");	

//----------------------------------------- mov LDANCER1_Motor down and check Ldancer encoder -------------------------------------------------
	temp_left_before= ReadEncoder(0);
	delay(10);	

	temp_right_before= ReadEncoder(1);
	
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LDANCER1_Motor,true,450);				//move Rloading down
	counter =0;
	while ( counter < 300)
	{
		counter = counter + 1;
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//if LS_LDANCER1_DN is dn then move stop
		if ((response.Value & F1_LS_LDANCER1_DN) != F1_LS_LDANCER1_DN  )
			counter=350;
		
			delay(100);	
	}
		stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LDANCER1_Motor, 3);					//hold Rloading high z
	//	if (counter == 300) 								
//	{	
//		Units_status[4,1]="Fail";
//		stubManager.Write("LS_LDANCER_Left_DN\tFail\n");	
//		return 12;
//	}
	DialogResult result2 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	
	if(result2 == DialogResult.No)
		{
			Units_status[4,1]="Fail";
			stubManager.Write("LS_LDANCER_Left_DN Not calibrate\n");
			return 12;
		}
	else
	{
	Units_status[4,1]="Pass";
	stubManager.Write("LS_LDANCER_Left_DN\tPass\n");	
	}
	Units_status[6,1]="Pass";
	stubManager.Write("LDANCER_Left_Motor\tPass\n");	

	temp_left_after= ReadEncoder(0);
	delay(10);	
	temp_right_after= ReadEncoder(1);
	delay(10);	

	stubManager.Write("temp_left_before="+temp_left_before + "\ttemp_left_after="+temp_left_after +"\n");
	delay(10);	

	stubManager.Write("temp_right_before="+temp_right_before + "\ttemp_right_after="+temp_right_after +"\n");
	delay(10);	
		
	DialogResult result = MessageBox.Show("SSI Dancer Left led is Green(not blinking)?", "Warning",MessageBoxButtons.YesNo);
	if(result == DialogResult.No)
		{
			Units_status[7,1]="Fail";
			stubManager.Write("LDANCER_Left_SSI\tFail\n");
			return 9;
			
		}

	if (temp_left_after>temp_left_before)
		temp_left_before=temp_left_before+0x4000;
		temp_left_before=temp_left_before-temp_left_after;			
			if ((temp_left_before> 5000) || (temp_left_before <200))
				{
					Units_status[7,1]="Fail";
					stubManager.Write("LDANCER_Left_SSI\tFail\n");
					return 9;
				}
			Units_status[7,1]="Pass"; 
			stubManager.Write("LDANCER_Left_SSI\tPass\n");
				
		
	DialogResult result3 = MessageBox.Show("SSI Dancer_Right_led is Green(not blinking)?", "Warning",MessageBoxButtons.YesNo);
	if(result3 == DialogResult.No)
		{
			Units_status[8,1]="Fail";
			stubManager.Write("LDANCER_Right_SSI\tFail\n");
			return 12;
		}


	if (temp_right_after<temp_right_before)
		temp_right_after=temp_right_after+0x4000;
		temp_right_before=temp_right_after-temp_right_before;			
			if ((temp_right_before< 5000) && (temp_right_before >200))
				{
					Units_status[8,1]="Pass";
					stubManager.Write("LDANCER_Right_SSI\tPass\n");
					return 9;
				}

//------------------------------------------ check  F1_LS_LSPARE2  ------------------------------------------------
	 response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//read LS
	
	if ((response.Value & F1_LS_LSPARE2) !=F1_LS_LSPARE2 )								//if F1_LS_LSPARE2 is up then error
	{	
		Units_status[10,1]="Fail";
		stubManager.Write("LS_LDANCER_Right_UP\tFail\n");	
		return 12;
	}
//----------------------------------------- check F1_LS_LDANCER2_UP -------------------------------------------------
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LDANCER2_Motor,false,450);				//move Lloading up
	counter =0;
	while ( counter < 300)
	{
		counter = counter + 1;
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//if F1_LS_LSPARE2 is up then move down
		if ((response.Value & F1_LS_LSPARE2) != F1_LS_LSPARE2  )
			counter=350;
		
			delay(100);	
	}
	stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LDANCER2_Motor, 3);					//hold Ldancer high z
		if (counter == 300) 								
	{	
		Units_status[10,1]="Fail";
		stubManager.Write("LS_LDANCER_Right_UP\tFail\n");	
		return 12;
	}

	 response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//read LS
	if ((response.Value & F1_LS_LSPARE1) !=F1_LS_LSPARE1 )								//if F1_LS_LSPARE1 is up then error
	{	
		Units_status[9,1]="Fail";
		stubManager.Write("LS_LDANCER_Right_DN\tFail\n");	
		return 12;
	}

	DialogResult result7= MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	
	if(result7== DialogResult.No)
		{
			Units_status[10,1]="Fail";
			stubManager.Write("LS_LDANCER_Right_UP Not calibrate\n");
			return 12;
		}
	
	Units_status[10,1]="Pass";
	stubManager.Write("LS_LDANCER_Right_UP\tPass\n");	

//----------------------------------------- mov LDANCER2_Motor down and check Ldancer encoder -------------------------------------------------
	temp_right_before= ReadEncoder(1);
	
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LDANCER2_Motor,true,450);				//move Rloading down
	counter =0;
	while ( counter < 300)
	{
		counter = counter + 1;
		response = stubManager.Run<StubFpgaReadRegResponse>("StubFpgaReadRegRequest" ,F1_LS_02_Direct);	//if F1_LS_LSPARE1 is dn then move stop
		if ((response.Value & F1_LS_LSPARE1) != F1_LS_LSPARE1  )
			counter=350;
		
			delay(100);	
	}
		stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LDANCER2_Motor, 3);					//hold Rloading high z
		if (counter == 300) 								
	{	
		Units_status[9,1]="Fail";
		stubManager.Write("LS_LDANCER_Right_DN\tFail\n");	
		return 12;
	}
	DialogResult result8 = MessageBox.Show("Limit Switch calibrate ?", "Warning",MessageBoxButtons.YesNo);
	
	if(result8 == DialogResult.No)
		{
			Units_status[9,1]="Fail";
			stubManager.Write("LS_LDANCER_Right_DN Not calibrate\n");
			return 12;
		}
	
	Units_status[9,1]="Pass";
	stubManager.Write("LS_LDANCER_Right_DN\tPass\n");	
	
	Units_status[11,1]="Pass";
	stubManager.Write("LDANCER_Right_Motor\tPass\n");	

	temp_right_after= ReadEncoder(1);

	stubManager.Write("temp_right_before="+temp_right_before + "\ttemp_right_after="+temp_right_after +"\n");


	if (temp_right_after<temp_right_before)
		temp_right_after=temp_right_after+0x4000;
		temp_right_before=temp_right_after-temp_right_before;			
			if ((temp_right_before< 5000) && (temp_right_before >200))
				{
					Units_status[8,1]="Pass";
					stubManager.Write("LDANCER_Right_SSI\tPass\n");
					return 12;
				}
			Units_status[8,1]="Fail";
			stubManager.Write("LDANCER_Right_SSI\tFail\n");	

				
	return 12;
}
//-------------------------------------------------------------
int Test_LDRIVING_LTFU()
{	
	stubManager.Run<StubMotorRunResponse>("StubMotorRunRequest" ,LDRIVING_Motor, true,200);				//move Ldriving clockwise 
	stubManager.Write("LDRIVING_Motor Motor rotate \n ");
	
	DialogResult result = MessageBox.Show("Are LDRIVING Motor rotate?", "Warning",MessageBoxButtons.YesNo);
	if(result == DialogResult.No)
		{
			Units_status[3,1]="Fail";
			stubManager.Write("LDRIVING Motor not rotate\n");
		}
	else 
		{
			Units_status[3,1]="Pass";
			stubManager.Write("LDRIVING Motor rotate\n");
		}
		stubManager.Run<StubMotorStopResponse>("StubMotorStopRequest" ,LDRIVING_Motor,3);		//stop motor

	return 0;
}