static int Main(string[] args)
        {
            //1. Logger initialization
            Logger  logger               = LogManager.GetCurrentClassLogger();
            int     TimePart             = 0;
            decimal PercentagePart       = 0M;
            bool?   RunSettingsPart      = null;
            bool?   HDDCheckSettingsPart = null;

            if (args.Length > 0)
            {
                if (args.Where(x => x.ToLower() == "-help").ToList().Count > 0)
                {
                    logger.Info("-----------------------------------------------------------------------------");
                    logger.Info("-t for Time setting in mins");
                    logger.Info("-p for Percentage setting");
                    logger.Info("-r for Run setting (True/False)");
                    logger.Info("-h for HDD Check (True/False)");
                    logger.Info("Example : >N3PS.File.Compare.exe  -hFalse");
                    logger.Info("Meaning program will be running 30 mins, 100% random record picked up and New table to be created for processing or not.");
                    logger.Info("-----------------------------------------------------------------------------");
                    return(0);
                }
                try
                {
                    var timePart = args.Where(x => x.ToLower().Contains("-t")).ToList();
                    if (timePart.Count > 0)
                    {
                        TimePart = Convert.ToInt32(timePart[0].ToLower().Replace("-t", ""));
                        logger.Info($"TimePart Argument Value : {TimePart}");
                    }


                    var percentagePart = args.Where(x => x.ToLower().Contains("-p")).ToList();
                    if (percentagePart.Count > 0)
                    {
                        PercentagePart = Convert.ToDecimal(percentagePart[0].ToLower().Replace("-p", ""));
                        logger.Info($"PercentagePart Argument Value : {PercentagePart}");
                    }

                    var runSettingsPart = args.Where(x => x.ToLower().Contains("-r")).ToList();
                    if (runSettingsPart.Count > 0)
                    {
                        RunSettingsPart = Convert.ToBoolean(runSettingsPart[0].ToLower().Replace("-r", ""));
                        logger.Info($"RunSettingsPart Argument Value : {RunSettingsPart}");
                    }


                    var runHddCheckPart = args.Where(x => x.ToLower().Contains("-h")).ToList();
                    if (runHddCheckPart.Count > 0)
                    {
                        HDDCheckSettingsPart = Convert.ToBoolean(runHddCheckPart[0].ToLower().Replace("-h", ""));
                        logger.Info($"HDDCheckSettingsPart Argument Value : {HDDCheckSettingsPart}");
                    }
                }
                catch (Exception excp)
                {
                    logger.Error("Error in processing the command level arguments. " + excp.ToString() + " --- " + excp.StackTrace);
                }
            }
            //2. XML File Initialization
            string FlatFileXmlName = @".\XMLFiles\FileFormat.xml";

            string SettingsXmlName = @".\XMLFiles\Settings.xml";

            //string ValidationRuleXmlName = @".\XMLFiles\ValidationRule.xml";

            //3. Convert FlatFile to C# objects
            FlatFile flatFile = new FlatFile();

            FlatFile fetchedFlatFileObj = flatFile.GetInstance(FlatFileXmlName, logger);

            if (fetchedFlatFileObj == null)
            {
                logger.Error($"Error while loading the Flat File XML : {FlatFileXmlName}");
                return(0);
            }


            //4.Convert Settings File to C# objects
            SettingsFile settingsFile       = new SettingsFile();
            SettingsFile fetchedSettingsObj = settingsFile.GetInstance(SettingsXmlName, logger);

            if (fetchedSettingsObj == null)
            {
                logger.Error($"Error while loading the Settings File XML : {SettingsXmlName}");
                return(0);
            }

            if (TimePart != 0)
            {
                logger.Info($"Overidden Time Part from Settings.xml: {TimePart}");
                fetchedSettingsObj.Time = TimePart;
            }

            if (PercentagePart != 0M)
            {
                logger.Info($"Overidden Percentage from Settings.xml: {PercentagePart}");
                fetchedSettingsObj.Percentage = PercentagePart;
            }


            if (RunSettingsPart != null)
            {
                logger.Info($"Overidden Run Settings from Settings.xml: {RunSettingsPart}");
                fetchedSettingsObj.NewRun = RunSettingsPart.Value;
            }


            logger.Info("Settings : Start ----------------------");
            logger.Info($"Time : {fetchedSettingsObj.Time}");
            logger.Info($"Percentage : {fetchedSettingsObj.Percentage}");
            logger.Info($"NewRun : {fetchedSettingsObj.NewRun}");

            logger.Info("Settings : END ----------------------");

            ////5. Convert ValidationRule to C# objects
            //ValidationRuleFile validationRuleFile = new ValidationRuleFile();
            //ValidationRuleFile fetchedValidationRuleObj = validationRuleFile.GetInstance(ValidationRuleXmlName, logger);

            //if (fetchedValidationRuleObj == null)
            //{
            //    logger.Error($"Error while loading the Validation Rule File XML : {ValidationRuleXmlName}");
            //    return 0;
            //}


            //var dllsDetails = fetchedValidationRuleObj.ValidationRules.Where(x => x.DLLInfo != null && !string.IsNullOrEmpty(x.DLLInfo.DLLName) ).ToList();

            //Hashtable assemblyDetails = new Hashtable();

            //if (dllsDetails.Count() > 0)
            //{
            //    foreach (ValidationsRule rule in dllsDetails)
            //    {
            //        FileInfo f = new FileInfo(@".\ExternalDLLs\" + rule.DLLInfo.DLLName);
            //        logger.Info($"Full File Name : {f.FullName}");
            //        if (!System.IO.File.Exists(f.FullName))
            //        {
            //            logger.Error($"External DLL is not exist {rule.DLLInfo.DLLName} in ExternalDLLs folder.");
            //            return 0;
            //        }
            //        else
            //        {
            //            Assembly assembly = Assembly.LoadFile(f.FullName);
            //            assemblyDetails.Add(rule.ColumnNumber, assembly);
            //        }
            //    }
            //}
            //6. HDD Size Check



            if (HDDCheckSettingsPart == null)
            {
                HDDCheckSettingsPart = true;
            }
            //Check for free space
            if (HDDCheckSettingsPart.Value)
            {
                HDDCheck check = new HDDCheck();
                bool     isFreeSpaceAvailable = check.IsEnoughSpaceAvailable(fetchedFlatFileObj.FlatFilePath1, logger);

                if (!isFreeSpaceAvailable)
                {
                    return(0);
                }
            }
            else
            {
                logger.Info("HDD Check is Skipped.");
            }

            //logger.Info($"Flat file Path : {fetchedFlatFileObj.FlatFilePath}");
            string       DBName          = "ICA";
            SQLiteHelper sqlManipulation = new SQLiteHelper();
            bool         isDBExist       = sqlManipulation.IsDBExist(DBName);

            if (!isDBExist)
            {
                sqlManipulation.CreateDB(DBName, logger);
            }

            //SQLiteHelper sqlLite = new SQLiteHelper();
            System.Data.SQLite.SQLiteConnection m_dbConnection = sqlManipulation.OpenDBConnection1(DBName);



            string tableName1 = "ICATable1";
            string tableName2 = "ICATable2";


            string tableNameDeleted1  = "ICADeletedTable1";
            string tableNameInserted2 = "ICAInsertedTable2";


            string CreateDeletedTableSQLQuery1  = flatFile.GetFlatFileDeletedTableScript(tableNameDeleted1, fetchedFlatFileObj);
            string CreateInsertedTableSQLQuery2 = flatFile.GetFlatFileInsertTableScript(tableNameInserted2, fetchedFlatFileObj);


            string     processedtableName1 = "ProcessedICATable1";
            string     processedtableName2 = "ProcessedICATable2";
            FileHelper helper = new FileHelper();

            if (fetchedSettingsObj.NewRun)
            {
                string CreateTableSQLQuery1 = flatFile.GetFlatFileTableScript(tableName1, fetchedFlatFileObj);
                string CreateTableSQLQuery2 = flatFile.GetFlatFileTableScript(tableName2, fetchedFlatFileObj);


                string CreateProcessedTableSQLQuery1 = flatFile.CreateFlatFileTableScript(processedtableName1);
                string CreateProcessedTableSQLQuery2 = flatFile.CreateFlatFileTableScript(processedtableName2);

                bool isExist = sqlManipulation.CheckTableExists(m_dbConnection, tableName1, logger);

                if (isExist)
                {
                    sqlManipulation.DeleteTable(m_dbConnection, DBName, tableName1, logger);
                }

                sqlManipulation.CreateTable(m_dbConnection, DBName, CreateTableSQLQuery1, logger);

                isExist = sqlManipulation.CheckTableExists(m_dbConnection, tableName2, logger);

                if (isExist)
                {
                    sqlManipulation.DeleteTable(m_dbConnection, DBName, tableName2, logger);
                }
                sqlManipulation.CreateTable(m_dbConnection, DBName, CreateTableSQLQuery2, logger);
                //sqlManipulation.DeleteTable(DBName, processedtableName1, logger);
                //sqlManipulation.DeleteTable(DBName, processedtableName2, logger);

                //sqlManipulation.CreateTable(DBName, CreateTableSQLQuery1, logger);
                //sqlManipulation.CreateTable(DBName, CreateTableSQLQuery2, logger);
                isExist = sqlManipulation.CheckTableExists(m_dbConnection, processedtableName1, logger);

                if (isExist)
                {
                    sqlManipulation.DeleteTable(m_dbConnection, DBName, processedtableName1, logger);
                }
                sqlManipulation.CreateTable(m_dbConnection, DBName, CreateProcessedTableSQLQuery1, logger);

                isExist = sqlManipulation.CheckTableExists(m_dbConnection, processedtableName2, logger);

                if (isExist)
                {
                    sqlManipulation.DeleteTable(m_dbConnection, DBName, processedtableName2, logger);
                }

                sqlManipulation.CreateTable(m_dbConnection, DBName, CreateProcessedTableSQLQuery2, logger);



                isExist = sqlManipulation.CheckTableExists(m_dbConnection, tableNameDeleted1, logger);

                if (isExist)
                {
                    sqlManipulation.DeleteTable(m_dbConnection, DBName, tableNameDeleted1, logger);
                }

                sqlManipulation.CreateTable(m_dbConnection, DBName, CreateDeletedTableSQLQuery1, logger);


                isExist = sqlManipulation.CheckTableExists(m_dbConnection, tableNameInserted2, logger);

                if (isExist)
                {
                    sqlManipulation.DeleteTable(m_dbConnection, DBName, tableNameInserted2, logger);
                }

                sqlManipulation.CreateTable(m_dbConnection, DBName, CreateInsertedTableSQLQuery2, logger);

                //sqlManipulation.CreateTable(DBName, CreateProcessedTableSQLQuery1, logger);
                //sqlManipulation.CreateTable(DBName, CreateProcessedTableSQLQuery2, logger);
                //sqlManipulation.CloseDBConnection(m_dbConnection);



                //var conn = new SQLiteConnection( "foofoo");


                List <DynamicClass1> objList = new List <DynamicClass1>();
                //SQLiteConnection m_dbConnection1 = sqlManipulation.OpenDBConnection(DBName);
                // m_dbConnection1.CreateTable<DynamicClass1>();
                helper.InsertInto(sqlManipulation, fetchedFlatFileObj, fetchedSettingsObj, m_dbConnection, DBName, tableName1, processedtableName1, fetchedFlatFileObj.FlatFilePath1, logger, objList, true);


                List <DynamicClass2> objList1 = new List <DynamicClass2>();
                helper.InsertInto(sqlManipulation, fetchedFlatFileObj, fetchedSettingsObj, m_dbConnection, DBName, tableName2, processedtableName2, fetchedFlatFileObj.FlatFilePath2, logger, objList1, false);
            }
            int table1Records = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection, tableName1, logger);


            //set


            logger.Info("Comaprison is started.");
            int table2Records = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection, tableName2, logger);

            //List< ProcessedDetails1> list1 = m_dbConnection.Query<ProcessedDetails1>($"SELECT IsError, Count(1) AS TotalRecords FROM {processedtableName1} GROUP BY IsError");

            m_dbConnection.Close();
            Thread.Sleep(1000);
            m_dbConnection = null;
            GC.Collect();
            GC.WaitForPendingFinalizers();

            System.Data.SQLite.SQLiteConnection m_dbConnection1 = sqlManipulation.OpenDBConnection1(DBName);
            //m_dbConnection1.Open();
            var list1 = sqlManipulation.GetTotalRecordsInTable(m_dbConnection1, $"SELECT IsError, Count(1) AS TotalRecords FROM {processedtableName1} GROUP BY IsError", logger);

            //m_dbConnection1.Open();
            helper.Compare(fetchedFlatFileObj, fetchedSettingsObj, sqlManipulation, m_dbConnection1, DBName, tableName1, tableName2, processedtableName1, processedtableName2, tableNameDeleted1, tableNameInserted2, table1Records, list1, logger);



            int tab1 = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection1, tableName1, logger);

            int tab2 = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection1, tableName2, logger);

            int insTab = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection1, tableNameInserted2, logger);

            int delTab = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection1, tableNameDeleted1, logger);

            int fetchedTab1 = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection1, processedtableName1, logger);

            int fetchedTab2 = sqlManipulation.GetTotalRecordsInTable1(m_dbConnection1, processedtableName2, logger);

            logger.Info("-----------------------Report--------------------------------");
            logger.Info($"{tableName1} : {tab1}");
            logger.Info($"{tableName2} : {tab2}");
            logger.Info($"{tableNameInserted2} : {insTab}");
            logger.Info($"{tableNameDeleted1} : {delTab}");
            logger.Info($"{processedtableName1} : {fetchedTab1}");
            logger.Info($"{processedtableName2} : {fetchedTab2}");
            logger.Info("-------------------------------------------------------");



            helper.WriteToFile(sqlManipulation, fetchedFlatFileObj, m_dbConnection1, DBName, tableNameInserted2, logger, insTab);
            helper.WriteToFile(sqlManipulation, fetchedFlatFileObj, m_dbConnection1, DBName, tableNameDeleted1, logger, delTab);
            sqlManipulation.CloseDBConnection(m_dbConnection1);

            /*DataSet dsTotalRecords = sqlManipulation.GetTotalRecords(m_dbConnection, tableName, logger);
             * FileHelper helper = new FileHelper();
             * ProcessedDetails processedDetails = helper.ValidateFile(fetchedFlatFileObj, fetchedSettingsObj, fetchedValidationRuleObj, sqlManipulation, m_dbConnection, DBName, tableName, assemblyDetails, dsTotalRecords, logger);
             *
             * DataSet dsTotalRecords1 = sqlManipulation.GetTotalRecords(m_dbConnection, tableName, logger);
             * int totalRecords = 0;
             * int totalError = 0;
             * int totalSuccessProcessed = 0;
             * if (dsTotalRecords1 != null)
             * {
             *  DataTable dt = dsTotalRecords1.Tables[0];
             *  foreach(DataRow dr in dt.Rows)
             *  {
             *      int tr = 0;
             *      if(dr["TotalRecords"] != DBNull.Value)
             *      {
             *          tr = Convert.ToInt32(dr["TotalRecords"].ToString());
             *          if (dr["IsError"] != DBNull.Value && Convert.ToBoolean(dr["IsError"].ToString()))
             *          {
             *              totalError = totalError + tr;
             *          }
             *          else
             *          {
             *
             *              totalSuccessProcessed = totalSuccessProcessed + tr;
             *
             *          }
             *
             *          totalRecords = totalRecords + tr;
             *      }
             *  }
             * }
             * logger.Info("------------------------------------------------------------");
             * logger.Info($"Total Records: " + processedDetails.TotalRecords);
             * logger.Info($"Total Records Processed: " + totalRecords);//(processedDetails.TotalErrorRecords + processedDetails.TotalSeccessfullyProcessedRecords));
             * logger.Info($"Total Error Records: " + totalError);// processedDetails.TotalErrorRecords);
             * logger.Info($"Total Successfully Processed Records: " + totalSuccessProcessed);// processedDetails.TotalSeccessfullyProcessedRecords);
             * logger.Info("------------------------------------------------------------");
             * sqlManipulation.CloseDBConnection(m_dbConnection);
             *
             * //sqlLite.CreateTable(DBName, CreateTableSQLQuery, logger);
             * //sqlLite.InsertRecord(DBName, tableName, 1, "Nothing", logger);
             * //DataSet dt = sqlLite.RetrieveRecord(DBName, tableName, 1,  logger);
             * //FileHelper f = new FileHelper();
             * //f.ValidateFile(@"C:\Users\vishal.chilka\Desktop\ZSB120OM.OUT");
             *
             * return 0;*/
            // sqlManipulation.CloseDBConnection(m_dbConnection);
            return(0);
        }