package com.dec.fbs9100;

import java.sql.ResultSet;
import java.util.ArrayList;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class AppParam {
	public final static String AppParamTableName = "tb_app_param";
	public final static String AppLog4jTableName = "tb_batt_61850_dev_x64_log4j";
	public final static String AppLog4j2_TableName = "tb_batt_61850_dev_x64_log4j2";
	public final static int AppParam_Discharge = 0;
	public final static int AppParam_Charge = 1;
	public final static int AppParam_PowerOff = 2;
	
	private MysqlConnPool m_Conn_Pool;
	private boolean MysqlDataTable_Exist = false;
	private MonitorParam m_MonitorParam = new MonitorParam();
	
	public AppParam()
	{
	}
	
	public AppParam(MysqlConnPool pool)
	{
		m_Conn_Pool = pool;
		getAppParam();
	}
	/***************************************************************************************
	public void checkAndCreateLog4jTable() {
		Logger logger = LogManager.getLogger(this.getClass());
		Sql_Mysql sql = null;
		try {
			sql = new Sql_Mysql(m_Conn_Pool);
			sql.sqlMysqlUseDB(Sql_Mysql.DB_AppSys);
			
			if(false == sql.sqlMysqlCheckIfTableExist(AppLog4jTableName)) {
				FBS9100_Task_Thread_SQL.createAppLog4jTable(m_Conn_Pool, 
										Sql_Mysql.DB_AppSys + ".`" + AppLog4jTableName + "`");
				
				logger.warn(Sql_Mysql.DB_AppSys + ".`" + AppLog4jTableName + "`" + " dose not exist, create now..." );
			}
			
			if(false == sql.sqlMysqlCheckIfTableExist(AppLog4j2_TableName)) {
				FBS9100_Task_Thread_SQL.createAppLog4j2_Table(m_Conn_Pool, 
										Sql_Mysql.DB_AppSys + ".`" + AppLog4j2_TableName + "`");
				logger.warn(Sql_Mysql.DB_AppSys + ".`" + AppLog4j2_TableName + "`" + " dose not exist, create now..." );
			}
			
		} catch (Exception e) {
			logger.error(e.toString(), e);
		} finally {
			try {
				sql.close_con();
			} catch (Exception e) {
				logger.error(e.toString(), e);
			}
		}
	}
	
	public void checkAndDeleteLog4jOldData() {
		Logger logger = LogManager.getLogger(this.getClass());
		Sql_Mysql sql = null;
		try {
			sql = new Sql_Mysql(m_Conn_Pool);
			FBS9100_Task_Thread_SQL.deleteAppLog4jTableOldData(m_Conn_Pool, 
									Sql_Mysql.DB_AppSys + ".`" + AppLog4j2_TableName + "`");
		} catch (Exception e) {
			logger.error(e.toString(), e);
		} finally {
			try {
				sql.close_con();
			} catch (Exception e) {
				logger.error(e.toString(), e);
			}
		}
	}
	*****************************************************************************************/
	/**
	 * ������param���������������������������������������������� �������������������������������m_MonitorParam������������������
	 * @param param
	 */
	public void copyAppParam(AppParam param)
	{
		m_MonitorParam.discharge_SaveDataTimeInterval = param.m_MonitorParam.discharge_SaveDataTimeInterval;
		m_MonitorParam.discharge_TestTimeLongMinimum = param.m_MonitorParam.discharge_TestTimeLongMinimum;
		m_MonitorParam.discharge_BattTestGroupCountMax = param.m_MonitorParam.discharge_BattTestGroupCountMax;
		m_MonitorParam.discharge_MonVolChangeLevel = param.m_MonitorParam.discharge_MonVolChangeLevel;
		m_MonitorParam.discharge_TestDataRecordCountMax = param.m_MonitorParam.discharge_TestDataRecordCountMax;
		
		m_MonitorParam.charge_SaveDataTimeInterval = param.m_MonitorParam.charge_SaveDataTimeInterval;
		m_MonitorParam.charge_TestTimeLongMinimum = param.m_MonitorParam.charge_TestTimeLongMinimum;
		m_MonitorParam.charge_BattTestGroupCountMax = param.m_MonitorParam.charge_BattTestGroupCountMax;
		m_MonitorParam.charge_MonVolChangeLevel = param.m_MonitorParam.charge_MonVolChangeLevel;
		m_MonitorParam.charge_TestDataRecordCountMax = param.m_MonitorParam.charge_TestDataRecordCountMax;
		
		m_MonitorParam.poweroff_SaveDataTimeInterval = param.m_MonitorParam.poweroff_SaveDataTimeInterval;
		m_MonitorParam.poweroff_TestTimeLongMinimum = param.m_MonitorParam.poweroff_TestTimeLongMinimum;
		m_MonitorParam.poweroff_BattTestGroupCountMax = param.m_MonitorParam.poweroff_BattTestGroupCountMax;
		m_MonitorParam.poweroff_MonVolChangeLevel = param.m_MonitorParam.poweroff_MonVolChangeLevel;
		m_MonitorParam.poweroff_TestDataRecordCountMax = param.m_MonitorParam.poweroff_TestDataRecordCountMax;
	}
	
	class MonitorParam {
		public int discharge_SaveDataTimeInterval = 10;
		public float discharge_MonVolChangeLevel = (float) 0.05;
		public int discharge_TestTimeLongMinimum = 60;
		public int discharge_TestDataRecordCountMax = 10000;
		public int discharge_BattTestGroupCountMax = 10;
		
		public int charge_SaveDataTimeInterval = 10;
		public float charge_MonVolChangeLevel = (float) 0.05;
		public int charge_TestTimeLongMinimum = 60;
		public int charge_TestDataRecordCountMax = 10000;
		public int charge_BattTestGroupCountMax = 10;
		
		public int poweroff_SaveDataTimeInterval = 10;
		public float poweroff_MonVolChangeLevel = (float) 0.05;
		public int poweroff_TestTimeLongMinimum = 60;
		public int poweroff_TestDataRecordCountMax = 10000;
		public int poweroff_BattTestGroupCountMax = 10;
		
		public boolean BattJunHengFN = false;
	}
	
	
	/**
	 * ������������type����������������������������������������������������������������������������������������������������
	 * @param type
	 * @return
	 */
	public int getSaveDataTimeInterval(int type)
	{
		int val = 0;
		switch(type)
		{
		case AppParam_Discharge: val = m_MonitorParam.discharge_SaveDataTimeInterval; 
			break;
		case AppParam_Charge: val = m_MonitorParam.charge_SaveDataTimeInterval; 
			break;
		case AppParam_PowerOff: val = m_MonitorParam.poweroff_SaveDataTimeInterval; 
			break;
		}
		return val;
	}
	
	/**
	 * ������������type��������MonVolChangeLevel
	 * @param type
	 * @return
	 */
	public float getMonVolChangeLevel(int type)
	{
		float val = 0;
		switch(type)
		{
		case AppParam_Discharge: val = m_MonitorParam.discharge_MonVolChangeLevel; 
			break;
		case AppParam_Charge: val = m_MonitorParam.charge_MonVolChangeLevel; 
			break;
		case AppParam_PowerOff: val = m_MonitorParam.poweroff_MonVolChangeLevel; 
			break;
		}
		return val;
	}
	
	/**
	 * ������������type��������TestTimeLongMinimum��
	 * @param type
	 * @return
	 */
	public int getTestTimeLongMinimum(int type)
	{
		int val = 0;
		switch(type)
		{
		case AppParam_Discharge: val = m_MonitorParam.discharge_TestTimeLongMinimum; 
			break;
		case AppParam_Charge: val = m_MonitorParam.charge_TestTimeLongMinimum; 
			break;
		case AppParam_PowerOff: val = m_MonitorParam.poweroff_TestTimeLongMinimum; 
			break;
		}
		return val;
	}
	
	/**
	 * ������������type ����������������������������TestDataRecordCountMax��
	 * @param type
	 * @return
	 */
	public int getTestDataRecordCountMax(int type)
	{
		int val = 0;
		switch(type)
		{
		case AppParam_Discharge: val = m_MonitorParam.discharge_TestDataRecordCountMax; 
			break;
		case AppParam_Charge: val = m_MonitorParam.charge_TestDataRecordCountMax; 
			break;
		case AppParam_PowerOff: val = m_MonitorParam.poweroff_TestDataRecordCountMax; 
			break;
		}
		return val;
	}
	
	/**
	 * ������������type��������BattTestGroupCountMax��
	 * @param type
	 * @return
	 */
	public int getBattTestGroupCountMax(int type)
	{
		int val = 0;
		switch(type)
		{
		case AppParam_Discharge: val = m_MonitorParam.discharge_BattTestGroupCountMax; 
			break;
		case AppParam_Charge: val = m_MonitorParam.charge_BattTestGroupCountMax; 
			break;
		case AppParam_PowerOff: val = m_MonitorParam.poweroff_BattTestGroupCountMax; 
			break;
		}
		return val;
	}
	
	/**
	 * ���������������������������������������� m_MonitorParam.BattJunHengFN��
	 * @return
	 */
	public boolean getBattJunHengFN()
	{
		return m_MonitorParam.BattJunHengFN;
	}
	
	/**
	 * ����������������������������������������������������������������������������tb_app_param������
	 */
	public void getAppParam()
	{
		Logger logger = LogManager.getLogger(this.getClass());
		Sql_Mysql sql = null;
		String sql_str;
		ResultSet res;
		
		try {
			sql = new Sql_Mysql(m_Conn_Pool);
			sql.sqlMysqlUseDB(Sql_Mysql.DB_PARAM);
			if(false == MysqlDataTable_Exist) {
				MysqlDataTable_Exist = sql.sqlMysqlCheckIfTableExist(AppParamTableName);
			}
			
			if(false == MysqlDataTable_Exist)
			{
				System.out.println(AppParamTableName + " is not exist, create it now...");
				ArrayList<String> al_sqlstr = new ArrayList<String>();
				
				sql_str = "CREATE TABLE `" + AppParamTableName + "` "
						+ "( `num` INT NOT NULL AUTO_INCREMENT, "
						+ "`param_name` VARCHAR(50) NULL, "
						+ "`param_value` VARCHAR(50) NULL, "
						+ "`param_caption` VARCHAR(200) NULL, "
						+ "PRIMARY KEY (`num`));";
				al_sqlstr.add(sql_str);
				
				sql_str = "INSERT INTO " + AppParamTableName
						+ " (param_name, "
						+ "param_value, "
						+ "param_caption)"
						+ " VALUES "
						//-------------------------------------------------------------------------------//
						+ "('discharge_SaveDataTimeInterval', '10', "
						+ "'discharge_TimeInterval for every data insert into db_batt_testdata by seconds'), "
						
						+ "('discharge_MonVolChangeLevel', '0.05', "
						+ "'discharge_MonVolChangeLevel for batt test data to save'), "
						
						+ "('discharge_TestTimeLongMinimum', '1800', "
						+ "'discharge_TestTimeLongMinimum for batttest data to store'), "
						
						+ "('discharge_TestDataRecordCountMax', '10000', "
						+ "'discharge_TestDataRecordCountMax for batttest data count to insert to mysql server'), "
						
						+ "('discharge_BattTestGroupCountMax', '10', "
						+ "'discharge_BattTestGroupCountMax for batttest thread count to work at the same time'), "
						//-------------------------------------------------------------------------------//
						+ "('charge_SaveDataTimeInterval', '10', "
						+ "'charge_TimeInterval for every data insert into db_batt_testdata by seconds'), "
						
						+ "('charge_MonVolChangeLevel', '0.05', "
						+ "'charge_MonVolChangeLevel for batt test data to save'), "
						
						+ "('charge_TestTimeLongMinimum', '1800', "
						+ "'charge_TestTimeLongMinimum for batttest data to store'), "
						
						+ "('charge_TestDataRecordCountMax', '10000', "
						+ "'charge_TestDataRecordCountMax for batttest data count to insert to mysql server'), "
						
						+ "('charge_BattTestGroupCountMax', '10', "
						+ "'charge_BattTestGroupCountMax for batttest thread count to work at the same time'), "
						//-------------------------------------------------------------------------------//
						+ "('poweroff_SaveDataTimeInterval', '10', "
						+ "'poweroff_TimeInterval for every data insert into db_batt_testdata by seconds'), "
						
						+ "('poweroff_MonVolChangeLevel', '0.05', "
						+ "'poweroff_MonVolChangeLevel for batt test data to save'), "
						
						+ "('poweroff_TestTimeLongMinimum', '1800', "
						+ "'poweroff_TestTimeLongMinimum for batttest data to store'), "
						
						+ "('poweroff_TestDataRecordCountMax', '10000', "
						+ "'poweroff_TestDataRecordCountMax for batttest data count to insert to mysql server'), "
						
						+ "('poweroff_BattTestGroupCountMax', '10', "
						+ "'poweroff_BattTestGroupCountMax for batttest thread count to work at the same time'), "
						//-------------------------------------------------------------------------------//
						+ "('BattJunHengFN', 'false', "
						+ "'BattJunHengFN for batt monomer to be balance')";
				
				al_sqlstr.add(sql_str);
				
				for(int n=0; n<al_sqlstr.size(); n++)
					sql.sqlMysqlExecute(al_sqlstr.get(n));
			}
			
			sql_str = "SELECT * FROM  " + AppParamTableName;
			res = sql.sqlMysqlQuery(sql_str);
			String pm_name;
			while(res.next())
			{
				pm_name = res.getString("param_name");
				//---------------------------------------------------------------------------//
				if(pm_name.equals("discharge_SaveDataTimeInterval"))
					m_MonitorParam.discharge_SaveDataTimeInterval = res.getInt("param_value");
				else if(pm_name.equals("discharge_MonVolChangeLevel"))
					m_MonitorParam.discharge_MonVolChangeLevel = res.getFloat("param_value");
				else if(pm_name.equals("discharge_TestTimeLongMinimum"))
					m_MonitorParam.discharge_TestTimeLongMinimum = res.getInt("param_value");
				else if(pm_name.equals("discharge_TestDataRecordCountMax"))
					m_MonitorParam.discharge_TestDataRecordCountMax = res.getInt("param_value");
				else if(pm_name.equals("discharge_BattTestGroupCountMax"))
					m_MonitorParam.discharge_BattTestGroupCountMax = res.getInt("param_value");
				//---------------------------------------------------------------------------//
				else if(pm_name.equals("charge_SaveDataTimeInterval"))
					m_MonitorParam.charge_SaveDataTimeInterval = res.getInt("param_value");
				else if(pm_name.equals("charge_MonVolChangeLevel"))
					m_MonitorParam.charge_MonVolChangeLevel = res.getFloat("param_value");
				else if(pm_name.equals("charge_TestTimeLongMinimum"))
					m_MonitorParam.charge_TestTimeLongMinimum = res.getInt("param_value");
				else if(pm_name.equals("charge_TestDataRecordCountMax"))
					m_MonitorParam.charge_TestDataRecordCountMax = res.getInt("param_value");
				else if(pm_name.equals("charge_BattTestGroupCountMax"))
					m_MonitorParam.charge_BattTestGroupCountMax = res.getInt("param_value");
				//---------------------------------------------------------------------------//
				else if(pm_name.equals("poweroff_SaveDataTimeInterval"))
					m_MonitorParam.poweroff_SaveDataTimeInterval = res.getInt("param_value");
				else if(pm_name.equals("poweroff_MonVolChangeLevel"))
					m_MonitorParam.poweroff_MonVolChangeLevel = res.getFloat("param_value");
				else if(pm_name.equals("poweroff_TestTimeLongMinimum"))
					m_MonitorParam.poweroff_TestTimeLongMinimum = res.getInt("param_value");
				else if(pm_name.equals("poweroff_TestDataRecordCountMax"))
					m_MonitorParam.poweroff_TestDataRecordCountMax = res.getInt("param_value");
				else if(pm_name.equals("poweroff_BattTestGroupCountMax"))
					m_MonitorParam.poweroff_BattTestGroupCountMax = res.getInt("param_value");
				//---------------------------------------------------------------------------//
				else if(pm_name.equals("BattJunHengFN"))
					m_MonitorParam.BattJunHengFN = res.getBoolean("param_value");
			}
		}
		catch (Exception e) {
			logger.error(e.toString(), e);
		}
		finally
		{
			try {
				sql.close_con();
			} catch (Exception e) {
				logger.error(e.toString(), e);
			}
		}
		//--------------------------------------------------------------------------------------------------------//
		if(m_MonitorParam.discharge_SaveDataTimeInterval < 5) m_MonitorParam.discharge_SaveDataTimeInterval = 5;
		if(m_MonitorParam.discharge_SaveDataTimeInterval > 600) m_MonitorParam.discharge_SaveDataTimeInterval = 600;
		
		if(m_MonitorParam.discharge_MonVolChangeLevel < 0.001) m_MonitorParam.discharge_MonVolChangeLevel = (float) 0.001;
		if(m_MonitorParam.discharge_MonVolChangeLevel > 1) m_MonitorParam.discharge_MonVolChangeLevel = 1;
		
		if(m_MonitorParam.discharge_TestTimeLongMinimum < 60) m_MonitorParam.discharge_TestTimeLongMinimum = 60;
		if(m_MonitorParam.discharge_TestTimeLongMinimum > 3600) m_MonitorParam.discharge_TestTimeLongMinimum = 3600;
		
		if(m_MonitorParam.discharge_TestDataRecordCountMax < 5000) m_MonitorParam.discharge_TestDataRecordCountMax = 5000;
		if(m_MonitorParam.discharge_TestDataRecordCountMax > 20000) m_MonitorParam.discharge_TestDataRecordCountMax = 20000;
		
		if(m_MonitorParam.discharge_BattTestGroupCountMax < 10) m_MonitorParam.discharge_BattTestGroupCountMax = 10;
		if(m_MonitorParam.discharge_BattTestGroupCountMax > 350) m_MonitorParam.discharge_BattTestGroupCountMax = 350;
		//--------------------------------------------------------------------------------------------------------//
		if(m_MonitorParam.charge_SaveDataTimeInterval < 5) m_MonitorParam.charge_SaveDataTimeInterval = 5;
		if(m_MonitorParam.charge_SaveDataTimeInterval > 600) m_MonitorParam.charge_SaveDataTimeInterval = 600;
		
		if(m_MonitorParam.charge_MonVolChangeLevel < 0.001) m_MonitorParam.charge_MonVolChangeLevel = (float) 0.001;
		if(m_MonitorParam.charge_MonVolChangeLevel > 1) m_MonitorParam.charge_MonVolChangeLevel = 1;
		
		if(m_MonitorParam.charge_TestTimeLongMinimum < 60) m_MonitorParam.charge_TestTimeLongMinimum = 60;
		if(m_MonitorParam.charge_TestTimeLongMinimum > 3600) m_MonitorParam.charge_TestTimeLongMinimum = 3600;
		
		if(m_MonitorParam.charge_TestDataRecordCountMax < 5000) m_MonitorParam.charge_TestDataRecordCountMax = 5000;
		if(m_MonitorParam.charge_TestDataRecordCountMax > 20000) m_MonitorParam.charge_TestDataRecordCountMax = 20000;
		
		if(m_MonitorParam.charge_BattTestGroupCountMax < 10) m_MonitorParam.charge_BattTestGroupCountMax = 10;
		if(m_MonitorParam.charge_BattTestGroupCountMax > 350) m_MonitorParam.charge_BattTestGroupCountMax = 350;
		//--------------------------------------------------------------------------------------------------------//
		if(m_MonitorParam.poweroff_SaveDataTimeInterval < 5) m_MonitorParam.poweroff_SaveDataTimeInterval = 5;
		if(m_MonitorParam.poweroff_SaveDataTimeInterval > 600) m_MonitorParam.poweroff_SaveDataTimeInterval = 600;
		
		if(m_MonitorParam.poweroff_MonVolChangeLevel < 0.001) m_MonitorParam.poweroff_MonVolChangeLevel = (float) 0.001;
		if(m_MonitorParam.poweroff_MonVolChangeLevel > 1) m_MonitorParam.poweroff_MonVolChangeLevel = 1;
		
		if(m_MonitorParam.poweroff_TestTimeLongMinimum < 60) m_MonitorParam.poweroff_TestTimeLongMinimum = 60;
		if(m_MonitorParam.poweroff_TestTimeLongMinimum > 3600) m_MonitorParam.poweroff_TestTimeLongMinimum = 3600;
		
		if(m_MonitorParam.poweroff_TestDataRecordCountMax < 5000) m_MonitorParam.poweroff_TestDataRecordCountMax = 5000;
		if(m_MonitorParam.poweroff_TestDataRecordCountMax > 20000) m_MonitorParam.poweroff_TestDataRecordCountMax = 20000;
		
		if(m_MonitorParam.poweroff_BattTestGroupCountMax < 10) m_MonitorParam.poweroff_BattTestGroupCountMax = 10;
		if(m_MonitorParam.poweroff_BattTestGroupCountMax > 350) m_MonitorParam.poweroff_BattTestGroupCountMax = 350;
		//--------------------------------------------------------------------------------------------------------//
	}
}