using System using System Collections Generic using System Diagnostics

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using Yaka.Tests;

namespace TestRunner
{
    public class Program
    {
        private const string AccountPreffix = "TESTBOT";
        public const sbyte ActivityExecutionStopped = -1;
        public const sbyte ActivityExecutionSucces = 0;
        public const sbyte InitializingRealmDataFailed = 1;
        public const sbyte TestExecutionFailed = 2;
        public const sbyte ActivityFailed = 3;
        public const sbyte UnknowActivity = 4;
        public const sbyte InvalidParametersCount = 5;
        public const sbyte InitDataFileNotFound = 6;
        public const sbyte DeserializationInitDataFailed = 7;
        public const sbyte InitDataFileOpenFailed = 8;
        public const sbyte UnknowError = 127;

        private static readonly string _logPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) +
                                         @".\TestRunnersLog";

        private const string lOperationDescription = "Initialization data file loading fail.";


        private static Logger _logger;

        public static int Main(string[] args)
        {
            //NOTE: to debug
            //Console.ReadKey();
            Debugger.Launch();

            CreateLogDirectory();

            try
            {
                if (args.Length != 6)
                {
                    //Console.WriteLine("Not enoenough command line parameters. 5 expected but {0} found.", args.Length);
                    Environment.Exit(InvalidParametersCount);
                }

                string activityName = args[0];
                string testRunnerId = args[1];
                string initDataFileName = args[2];
                string sessionName = args[3];
                string accountIds = args[4];
                bool isInitializatonMode = (args[5] == "1");

                string logName = string.Format(@"{0}\{1}_{2}.txt", _logPath, sessionName,
                                               testRunnerId);

                string crashLogName = string.Format(@"{0}\{1}_crash_{2}.txt", _logPath, sessionName,
                                                    testRunnerId);

                _logger = new Logger(logName, crashLogName);
                Console.SetOut(_logger.InfoWriter);

                _logger.Info("Starting test activity {0}", activityName);
                

                #region Загрузка YakaTestInitializationData

                ConnectionData testInitData = null;

                if (File.Exists(initDataFileName))
                {
                    StreamReader streamReader = null;
                    try
                    {
                        streamReader = File.OpenText(initDataFileName);
                    }
                    catch (Exception ex)
                    {   
                        _logger.Error("{0} File open exception: {1}", lOperationDescription, ex.Message);
                        Environment.Exit(InitDataFileOpenFailed);
                    }

                    BinaryFormatter serializer = new BinaryFormatter();
                    try
                    {
                        testInitData = (ConnectionData)serializer.Deserialize(streamReader.BaseStream);
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("{0} Error on deserializing YakaTestInitializationData: {1}",
                                      lOperationDescription, ex);
                        Environment.Exit(DeserializationInitDataFailed);
                    }
                }
                else
                {
                    _logger.Error("{0} File <{1}> not found.", lOperationDescription, initDataFileName);
                    Environment.Exit(InitDataFileNotFound);
                }

                #endregion
                try
                {
                    IPerformanceTestActivity activity = LoadActivity(activityName, testInitData, accountIds,
                                                                     testRunnerId);

                    if (isInitializatonMode)
                    {   
                        try
                        {
                            activity.InitRealmData();
                            Environment.Exit(ActivityExecutionSucces);
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("{0}", ex);
                            Environment.Exit(InitializingRealmDataFailed);
                        }
                    }
                    else
                    {
                        try
                        {
                            activity.RunTest();
                        }
                        catch (Exception ex)
                        {
                            _logger.Error("{0}", ex);
                            Environment.Exit(TestExecutionFailed);
                        }
                    }

                    if (activity.IsPassed())
                    {
                        Environment.Exit(ActivityExecutionSucces);
                    }
                    else
                    {
                        Environment.Exit(ActivityFailed);
                    }
                }
                catch(Exception)
                {
                    _logger.Error("Unknown activity '{0}'. Check spelling or verify that activity "
                                  + "implements ITestActivity or ITestSessionActivity.",
                                  activityName);
                    Environment.Exit(UnknowActivity);
                }

                Environment.Exit(ActivityExecutionSucces);
                return ActivityExecutionSucces;
            }
            catch (Exception ex)
            {
                _logger.Error("{0}", ex);
                Environment.Exit(UnknowError);
                return UnknowError;
            }
        }

        private static IPerformanceTestActivity LoadActivity(string activityName, ConnectionData connectionData, string accountsId, string testRunnerId)
        {
            Assembly assembly =
                Assembly.LoadFrom(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\PerformanceTests.dll");
            

            IPerformanceTestActivity activity;
            Type activityType = Array.Find(assembly.GetTypes(), t => t.Name == activityName);

            if (activityType != null)
            {
                string[] accounts = GetAccounts(accountsId);

                activity = (IPerformanceTestActivity)Activator.CreateInstance(activityType,
                                                                           connectionData.EntryPointHost,
                                                                           connectionData.EntryPointPort,
                                                                           accounts, testRunnerId);
            }
            else
            {
                throw new TypeLoadException(string.Format("Failed to create instance of type - {0}", activityType.Name));
            }

            return activity;
        }

        private static string[] GetAccounts(string accountIds)
        {
            List<string> accounts = new List<string>();
            int[] ids = DecodeAccountsIds(accountIds);
            for (int i = 0; i < ids.Length; i++)
            {
                accounts.Add(string.Format("{0}{1}", AccountPreffix, ids[i]));
            }

            return accounts.ToArray();
        }


        private static int[] DecodeAccountsIds(string encodedString)
        {
            string[] ids = encodedString.Split(' ');

            List<int> result = new List<int>();
            foreach (string id in ids)
            {
                int accountId = Int32.Parse(id);
                result.Add(accountId);
            }

            return result.ToArray();
        }


        private static void CreateLogDirectory()
        {
            try
            {
                Directory.CreateDirectory(_logPath);
            }
            catch (Exception)
            {   
                Environment.Exit(1);
            }
        }
    }
}