using System;
using System.Collections.Generic;
using System.Linq;

namespace TINK.Model.Logging
{
    public class LoggingDirectoryManager : ILoggingDirectoryManager
    {
        /// <summary> Name of logging subdirectory.</summary>
        private const string LOGDIRECTORYTITLE = "Log";

        /// <summary> Prevents an invalid instance to be created. </summary>
        private LoggingDirectoryManager() { }

        public LoggingDirectoryManager(
            Func<string, IList<string>> p_oFileListProvider, 
            Func<string, bool> p_oDirectoryExistsChecker,
            Action<string> p_oDirectoryCreator,
            Action<string> p_oFileEraser,
            string p_oLogFilePath,
            char p_strDirectorySeparatorChar,
            int p_iRetainedFilesCountLimit)
        {
            m_oFileListProvider = p_oFileListProvider ?? throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. File list provider delegate can not be null.");

            if (p_oDirectoryExistsChecker == null)
            {
                throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. Directory existance checker delegate can not be null.");
            }

            if (p_oDirectoryCreator == null)
            {
                throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. Directory creator delegate can not be null.");
            }

            m_oFileEraser = p_oFileEraser ?? throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. File eraser delegate can not be null.");

            if (string.IsNullOrEmpty(p_oLogFilePath))
            {
                throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. Log file path can not be null or empty.");
            }

            if (string.IsNullOrEmpty(p_strDirectorySeparatorChar.ToString()))
            {
                throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. Directory separtor character can not be null or empty.");
            }

            if (p_iRetainedFilesCountLimit < 1)
            {
                throw new ArgumentException($"Can not instantiate {nameof(LoggingDirectoryManager)}- object. Count of retained log files is {p_iRetainedFilesCountLimit} but must be equal or larger one.");
            }

            DirectorySeparatorChar = p_strDirectorySeparatorChar.ToString();

            LogFilePath = $"{p_oLogFilePath}{DirectorySeparatorChar}{LOGDIRECTORYTITLE}";


            m_iRetainedFilesCountLimit = p_iRetainedFilesCountLimit;

            if (string.IsNullOrEmpty(LogFileTitle))
            {
                LogFileTitle = $"{ DateTime.Now:yyyy_MM_dd_HH_mm_ss}.jsnl";
            }

            // Create directory if direcotry does not exist.
            if (p_oDirectoryExistsChecker(LogFilePath) == false)
            {
                try
                {
                    p_oDirectoryCreator(LogFilePath);
                }
                catch (Exception l_oException)
                {

                    throw new FileOperationException($"Logging directory {LogFilePath} could not be created successfully.", l_oException);
                }

            }
        }

        /// <summary> Deletes files which are out of retainment scope. </summary>
        public void DeleteObsoleteLogs()
        {
            var l_oExceptions = new List<Exception>();
            var l_oSortedFileArray = m_oFileListProvider(LogFilePath).OrderByDescending(x => x).ToArray();

            for (int l_iIndex = l_oSortedFileArray.Length - 1; 
                l_iIndex >= m_iRetainedFilesCountLimit - 1; /* files remaining count must be  m_iRetainedFilesCountLimit - 1 because new log file will be added afterwards */ 
                l_iIndex --)
            {
                try
                {
                    m_oFileEraser(l_oSortedFileArray[l_iIndex]);
                }
                catch (Exception l_oExpetion)
                {
                    // Getting list of log files found.
                    l_oExceptions.Add(l_oExpetion);
                }
            }

            if (l_oExceptions.Count <= 0)
            {
                return;
            }

            throw new AggregateException("Deleting obsolete log files failed.", l_oExceptions.ToArray());
        }

        /// <summary> Gets all log files in logging directory. </summary>
        /// <param name="p_oLogger"></param>
        /// <returns>List of log files.</returns>
        public IList<string> GetLogFiles()
        {
            try
            {
                return m_oFileListProvider(LogFilePath).OrderBy(x => x).ToList();
            }
            catch (Exception l_oExpetion)
            {
                // Getting list of log files found.
                throw new FileOperationException("Getting list of log files failed.", l_oExpetion);
            }
        }

        /// <summary>Holds delegate to provide file names.</summary>
        private readonly Func<string, IList<string>> m_oFileListProvider;

        /// <summary>Holds delegate to delete files.</summary>
        private readonly Action<string> m_oFileEraser;

        /// <summary>Holds delegate to provide file names.</summary>
        private int m_iRetainedFilesCountLimit;

        /// <summary> Holds the log file name. </summary>
        private string LogFileTitle { get; }

        /// <summary> Holds the log file name. </summary>
        public string LogFilePath { get; }

        /// <summary> Holds the directory separator character. </summary>
        private string DirectorySeparatorChar { get; }

        /// <summary> Holds the log file name. </summary>
        public string LogFileName { get { return $"{LogFilePath}{DirectorySeparatorChar}{LogFileTitle}"; } }
    }
}