package com.dev.ntm;
import java.util.ArrayList;
import java.util.Date;

public class BattTestData {
	final public static int BATT_MON_COUNT_MAX = 512;
	
	final public static byte BATTDATA_NULL = 0;
	final public static byte BATTDATA_FLOAT = 1;
	final public static byte BATTDATA_CHARGE = 2;
	final public static byte BATTDATA_DISCHARGE = 3;
	final public static byte BATTDATA_JUNCHARGE = 4;
	final public static byte BATTDATA_RES = 5;
	final public static byte BATTDATA_SER = 6;
	final public static byte BATTDATA_TMP = 7;
	final public static byte BATTDATA_CONNRES = 8;
	final public static byte BATTDATA_MONITOR = 9;
	
	final public static byte BATTSTATE_NULL = 0;
	final public static byte BATTSTATE_FLOAT = 1;
	final public static byte BATTSTATE_CHARGE = 2;
	final public static byte BATTSTATE_DISCHARGE = 3;
	final public static byte BATTSTATE_JUNCHARGE = 4;
	
	final public static byte TEST_LOADER_REALLOADER = 1;
	final public static byte TEST_LOADER_FBI_IDCE = 2;
	final public static byte TEST_LOADER_FBS9100S = 3;
	
	public static final byte MonData_CapVol = 0;
	public static final byte MonData_RealCap = 1;
	public static final byte MonData_RestCap = 2;
	public static final byte MonData_CapPercent = 3;
	public static final byte MonData_Vol = 4;
	public static final byte MonData_Res = 5;
	public static final byte MonData_Ser = 6;
	public static final byte MonData_Tmp = 7;
	public static final byte MonData_ConnRes = 8;
	public static final byte MonData_SerPercent = 9;
	
	public boolean data_act;
	public int StationId;
	public String StationName;
	public byte[] StationIp = new byte[4];
	public int BattGroupId = 10001;
	public int BattGroupNum = 1;
	public int BattState;
	public int BattTestStopType = 0;
	public int BattTestDevType = 0;
	public int MonCount = 24;
	public float MonCapStd = 1;
	public float MonSerStd = 1;
	public float MonVolStd = 0;
	
	private int[] monNum = new int[BATT_MON_COUNT_MAX];
	private float[] monVol = new float[BATT_MON_COUNT_MAX];
	private float[] monRealCap = new float[BATT_MON_COUNT_MAX];
	private float[] monRestCap = new float[BATT_MON_COUNT_MAX];
	private float[] monCapPercent = new float[BATT_MON_COUNT_MAX];
	private float[] monRes = new float[BATT_MON_COUNT_MAX];
	private float[] monSer = new float[BATT_MON_COUNT_MAX];
	private float[] monTmp = new float[BATT_MON_COUNT_MAX];
	private float[] monConnRes = new float[BATT_MON_COUNT_MAX];
	private float[] monSerCapPercent = new float[BATT_MON_COUNT_MAX];
	
	public ArrayList<TestData>  al_TestData = new ArrayList<TestData>();
	
	public static class MonData
	{
		public int monNum;
		public float monVol = 0;
		public float monRes = 0;
		public float monSer = 0;
		public float connRes = 0;
		public float monTmp = 0;
	}
	
	public static class TestData
	{
		public int testRecordCount = 0;
		public int testType = 0;
		public boolean data_Available = true;
		public Date startTestTime = new Date();
		public Date recordTime = new Date();
		public int recordNum = 0;
		public int testTimeLong = 0;
		public float onlineVol = 0;
		public float groupVol = 0;
		public float groupTmp = 0;
		public float testCurr = 0;
		public float testCap = 0;
		
		public int mMaxMonNum = 0;
		public float mMaxMonVol = 0;
		public int mMinMonNum = 0;
		public float mMinMonVol = 0;
		public ArrayList<MonData> MonVol = new ArrayList<MonData>();
		
		public void clearData()
		{
			testRecordCount = 0;
			testType = 0;
			data_Available = true;
			startTestTime = new Date();
			recordTime = new Date();
			testTimeLong = 0;
			onlineVol = 0;
			groupVol = 0;
			testCurr = 0;
			testCap = 0;
			MonVol.clear();
		}
		
		public ArrayList<MonData> cloneMonVol(ArrayList<MonData> al_data)
		{
			ArrayList<MonData> a_dt = new ArrayList<MonData>();
			for(int n=0; n<al_data.size(); n++)
			{
				MonData dt = new MonData();
				dt.monNum = al_data.get(n).monNum;
				dt.monVol = al_data.get(n).monVol;
				dt.monTmp = al_data.get(n).monTmp;
				dt.monRes = al_data.get(n).monRes;
				a_dt.add(dt);
			}
			
			return a_dt;
		}
		
		public void makeMaxMinMonVol()
		{
			float maxvol = -90000;
			float minvol = 90000;
			for(int n=0; n<MonVol.size(); n++)
			{
				if(maxvol < MonVol.get(n).monVol)
				{
					maxvol = MonVol.get(n).monVol;
					mMaxMonNum = n+1;
				}
				if(minvol > MonVol.get(n).monVol)
				{
					minvol = MonVol.get(n).monVol;
					mMinMonNum = n+1;
				}
			}
			
			mMaxMonVol = maxvol;
			mMinMonVol = minvol;
		}
		
		public float getMaxMonVol()
		{
			float maxvol = -90000;
			for(int n=0; n<MonVol.size(); n++)
			{
				if(maxvol < MonVol.get(n).monVol)
				{
					maxvol = MonVol.get(n).monVol;
				}
			}
			return maxvol;
		}
		
		public float getMinMonVol()
		{
			float minvol = 90000;
			for(int n=0; n<MonVol.size(); n++)
			{
				if(minvol > MonVol.get(n).monVol)
				{
					minvol = MonVol.get(n).monVol;
				}
			}
			return minvol;
		}
	}
	
	public void clearAllData()
	{
		MonCount = 0;
		al_TestData.clear();
		al_TestData.trimToSize();
		al_TestData = new ArrayList<TestData>();
	}
	
	public void clearToLeftOneZeroData()
	{
		MonCount = 0;
		al_TestData.clear();
		al_TestData.trimToSize();
		al_TestData = new ArrayList<TestData>();
		al_TestData.add(new TestData());
	}
	
	public int[] getMonNum(int rec_index)
	{
		int[] batt_num = this.monNum;
		if(rec_index < this.al_TestData.size())
		{	
			ArrayList<MonData> mVol = this.al_TestData.get(rec_index).MonVol;
			for(int n=0; n<mVol.size(); n++)
			{
				this.monNum[n] = mVol.get(n).monNum;
			}
		}
		return batt_num;
	}
	
	public float[] getMonData(byte type, int rec_index)
	{
		float[] batt_data = this.monVol;
		float max = 0;
		float min = 90000;
		
		double avg_curr = (this.al_TestData.get(rec_index).testCap*3600)/this.al_TestData.get(rec_index).testTimeLong;
		
		if(rec_index < this.al_TestData.size())
		{
			int HourRate = FBS_ComBase.GetHourRate(MonCapStd, avg_curr/*this.al_TestData.get(rec_index).testCurr*/);
			float test_cap = this.al_TestData.get(rec_index).testCap;
			
			ArrayList<MonData> mVol = this.al_TestData.get(rec_index).MonVol; 
			for(int n=0; n<mVol.size(); n++)
			{
				this.monVol[n] = mVol.get(n).monVol;
				if(max < this.monVol[n])
					max = this.monVol[n];
				if(min > this.monVol[n])
					min = this.monVol[n];
			}
			
			if(BattTestData.MonData_RestCap == type)
			{
				for(int n=0; n<this.MonCount; n++)
				{
					this.monRestCap[n] = (float) FBS_ComBase.GetMonomerCap(
																MonCapStd, 
																HourRate, 
																test_cap,
																max, 
																this.monVol[n], 
																MonVolStd, 
																FBS_ComBase.CapType_Rest);
				}
				batt_data = this.monRestCap;
			}
			else if(BattTestData.MonData_RealCap == type)
			{
				for(int n=0; n<this.MonCount; n++)
				{
					this.monRealCap[n] = (float) FBS_ComBase.GetMonomerCap(
																MonCapStd, 
																HourRate, 
																test_cap,
																max, 
																this.monVol[n], 
																MonVolStd, 
																FBS_ComBase.CapType_Real);
				}
				batt_data = this.monRealCap;
			}
			else if(BattTestData.MonData_CapPercent == type)
			{
				for(int n=0; n<this.MonCount; n++)
				{
					this.monCapPercent[n] = (float) (FBS_ComBase.GetMonomerCap(
																MonCapStd, 
																HourRate, 
																test_cap,
																max, 
																this.monVol[n], 
																MonVolStd, 
																FBS_ComBase.CapType_Real) / MonCapStd);
				}
				batt_data = this.monCapPercent;
			}
			else if(BattTestData.MonData_Res == type)
			{
				for(int n=0; n<mVol.size(); n++)
				{
					this.monRes[n] = mVol.get(n).monRes;
				}
				
				batt_data = this.monRes;
			}
			else if(BattTestData.MonData_Ser == type)
			{
				for(int n=0; n<mVol.size(); n++)
				{
					this.monSer[n] = mVol.get(n).monSer;
				}
				
				batt_data = this.monSer;
			}
			else if(BattTestData.MonData_Tmp == type)
			{
				for(int n=0; n<mVol.size(); n++)
				{
					this.monTmp[n] = mVol.get(n).monTmp;
				}
				
				batt_data = this.monTmp;
			}
			else if(BattTestData.MonData_ConnRes == type)
			{
				for(int n=0; n<mVol.size(); n++)
				{
					this.monConnRes[n] = mVol.get(n).connRes;
				}
				
				batt_data = this.monConnRes;
			}
			else if(BattTestData.MonData_SerPercent == type)
			{
				for(int n=0; n<mVol.size(); n++)
				{
					if(MonSerStd < 0.1) {
						this.monSerCapPercent[n] = 0;
					} else {
						this.monSerCapPercent[n] = (mVol.get(n).monSer / MonSerStd);
					}
				}
				
				batt_data = this.monSerCapPercent;
			}
		}
		return batt_data;
	}
	public float getGroupVol(int rec_index)
	{
		float vol = 0;
		for(int n=0; n<this.MonCount; n++)
		{
			vol += this.al_TestData.get(rec_index).MonVol.get(n).monVol;
		}
		return vol;
	}
	public int getTestTimeLong(int rec_index)
	{
		return al_TestData.get(rec_index).testTimeLong;
	}
	public static int getTestTypeFromFBOData(int type_tag) {
		int type = BattTestData.BATTSTATE_DISCHARGE;
		if(0xFD != type_tag) {
			type = BattTestData.BATTSTATE_CHARGE;
		}
		return type;
	}
}