FileUtils.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Collections;
using System.Diagnostics;
using static PageScraperLib.Utils.OutputUtils;

namespace PageScraperLib.Utils
{
    public class FileUtils
    {
        /*
                public static List<string> configKeys = new List<string>()
                {
                    "url",
                    "needle",
                    "attrib1",
                    "attrib2",
                    "baseURI",
                    "parentEl",
                    "parentAttrib1",
                    "parentAttrib2",
                    "childEl",
                    "childAttrib1",
                    "childAttrib2"
                };
        */

        // FOLDERS
        public static bool CreateFolder(string path)
        {
            DirectoryInfo dir = Directory.CreateDirectory(path);
            return dir.Exists;
        }
        /// <summary>
        /// Reads text file to String List
        /// </summary>
        /// <param name="path"></param>
        /// <returns>List of strings</returns>

        // READ LINES
        public static List<string> OpenFileAndReadLinesToStringList(string path)
        {
            if (File.Exists(path))
            {
                try
                {
                    return new List<string>(File.ReadAllLines(path));
                }
                catch (Exception e)
                {
                    print(log($"Error occurred on File.ReadAllLines(path)..\n{e.Message}"));
                }
            }
            return null;
        }

        /// <summary>
        /// Reads text file to String List
        /// </summary>
        /// <param name="path"></param>
        /// <returns>List of strings</returns>
        public static StringBuilder OpenFileAndReadLinesToStringBuilder(string path)
        {
            List<string> lines;
            StringBuilder sb = new StringBuilder();
            if (File.Exists(path))
            {
                try
                {
                    lines = new List<string>(File.ReadAllLines(path));
                    foreach (string line in lines) sb.AppendLine(line);
                    return sb;
                }
                catch (Exception e)
                {
                    print(log($"Error occurred on File.ReadAllLines(path)..\n{e.Message}"));
                }
            }
            else return null;



            return null;
        }

        /// <summary>
        /// Reads text file to String Array
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static string[] OpenFileAndReadLinesToStringArray(string path)
        {
            if (File.Exists(path))
            {
                try
                {
                    return File.ReadAllLines(path);
                }
                catch (Exception e)
                {
                    print(log($"Error occurred on File.ReadAllLines(path)..\n{e.Message}"));
                }
            }
            return null;
        }

        // String Tests
        /// <summary>
        /// Parses a string for starting string - with default = "#"
        /// </summary>
        /// <param name="line"></param>
        /// <returns>true if string starts-with expected string</returns>
        public static bool isLineComment(string line, string needle = "#")
        {
            return line.Trim().StartsWith(needle);
        }

        /// <summary>
        /// Parses a string for starting string - with default = "http"
        /// used to detect a url before attempting to navigate or download that resource
        /// </summary>
        /// <param name="line"></param>
        /// <param name="needle"></param>
        /// <returns></returns>
        public static bool isLineUrl(string line, string needle = "http")
        {
            return line.Trim().StartsWith(needle);
        }

        // OPEN FILE
        /// <summary>
        /// Reads text file to single string
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static string OpenFileAndReadAllText(string path)
        {
            if (File.Exists(path))
            {
                try
                {
                    return File.ReadAllText(path);
                }
                catch (Exception e)
                {
                    string message = "File exists, but there was an error opening it for reading!!!";
                    log(message);
                    e.Data.Add("AppErrorMessage", message);
                    throw;
                }
            }
            else
            {
                log("File does not exist, cannot open!!!");
                throw new FileNotFoundException();
            }
        }

        public static FileStream OpenFileAsFileStream(string path)
        {
            if (File.Exists(path))
            {
                try
                {
                    return File.OpenRead(path);
                }
                catch (Exception e)
                {
                    string message = "File exists, but there was an error opening it for reading!!!";
                    log(message);
                    e.Data.Add("AppErrorMessage", message);
                    throw;
                }
            }
            else
            {
                log("File does not exist, cannot open!!!");
                throw new FileNotFoundException();
            }
        }

        // WRITE TEXT
        public static bool OpenFileAndWriteText(string path, string contents)
        {
            try
            {
                File.WriteAllText(path, contents);
            }
            catch (Exception e)
            {
                log("Error attempting to write text to file");
                throw;
            }
            return File.Exists(path);
        }

        public static bool OpenFileAndWriteText(string path, StringBuilder contents)
        {
            OpenFileAndWriteText(path, contents.ToString());
            return File.Exists(path);
        }

        public static bool OpenFileAndWriteText(string path, string[] contents)
        {
            StringBuilder sb = new StringBuilder();

            foreach (string s in contents)
            {
                sb.AppendLine(s);
            }

            return OpenFileAndWriteText(path, sb);
        }

        public static bool OpenFileAndWriteText(string path, List<string> contents)
        {
            StringBuilder sb = new StringBuilder();

            foreach (string s in contents)
            {
                sb.AppendLine(s);
            }

            OpenFileAndWriteText(path, sb);
            return File.Exists(path);
        }

        public static bool OpenFileAndWriteText(string path, Dictionary<string, string> contents, string separator = "=")
        {
            StringBuilder sb = new StringBuilder();

            foreach (string s in contents.Keys)
            {
                sb.AppendLine($"{s}{separator}{contents[s]}");
            }

            OpenFileAndWriteText(path, sb);
            return File.Exists(path);
        }

        public static bool WriteTextToFile(string path, string contents)
        {
            OpenFileAndWriteText(path, contents);
            return File.Exists(path);
        }

        /*
                public static Dictionary<string,string> ParseConfigFileToDictionary(string path)
                {
                    string filetext = OpenFileAndReadAllText(path);
                    ArrayList textar= new ArrayList( filetext.Split(Environment.NewLine.ToString()));

                    string value;
                    Tuple<string, string> entry;
                    Dictionary<string, string> dict = new Dictionary<string, string>();

                    foreach ( string s in textar)
                    {
                        log(s);
                        entry = SplitConfigEntry(s);
                        if ( entry != null)
                        {
                            value = GetValueFromKey(entry);
                            if ( value != null && value.Length > 0 )
                            {
                                dict.Add(entry.Item1, entry.Item2);
                            }
                        }

                    }
                    log($"DictionaryLength: {dict.Count}");
                    return dict;
                }

                public static Tuple<string,string> SplitConfigEntry(string entry)
                {
                    if (entry.Contains("="))
                    {
                        var result = entry.Split('=');
                        return new Tuple<string,string>(result[0], result[1]);
                    }
                    else
                    {
                        return null;
                    }
                }

                public static string GetValueFromKey(Tuple<string, string> kv)
                {
                    if ( configKeys.Contains(kv.Item1))
                    {
                        return kv.Item2;
                    }
                    else
                    {
                        return null;
                    }
                }
        */

        #region FILE LISTS & SORTING

        public static string GetStringListToString(List<string> stringlist)
        {
            StringBuilder sb = new StringBuilder();
            log("GetStringListToString::List: START");
            int count = 0;
            foreach (string s in stringlist)
            {
                sb.AppendLine(s);
                log($"Item{++count}: {s}");
            }
            log("GetStringListToString::List: END");
            return sb.ToString();
        }




        public static List<string> ListFilesToListString(string path, string searchPattern)
        {
            List<string> list = list = new List<string>(Directory.EnumerateFiles(path));
            list.Sort();
            PrintListString(list);
            list.Reverse();
            PrintListString(list);
            return list;
        }

        public static List<FileInfo> ListFilesToListFileInfo(string path, string searchPattern)
        {
            List<FileInfo> files = new List<FileInfo>((FileInfo[])ListFilesToArrayFileInfo(path, searchPattern));
            log($"ListFilesToListFileInfo::Found [{files.Count}] Files...");
            return new List<FileInfo>(files);
        }

        public static Array ListFilesToArrayFileInfo(string path, string searchPattern)
        {
            Array files = new DirectoryInfo(path).GetFiles(searchPattern);
            log($"ListFilesToArrayFileInfo::Found [{files.Length}] Files...");
            return files;
        }

        public static void SortFilesByLastWriteTime(ref FileInfo[] files)
        {
            Array.Sort(files,
                delegate (FileInfo file1, FileInfo file2)
                {
                    return file1.LastWriteTime.CompareTo(file2.LastWriteTime);
                });
        }

        public static void SortFilesByLastWriteTimeDesc(ref FileInfo[] files)
        {
            Array.Sort(files,
                delegate (FileInfo file1, FileInfo file2)
                {
                    return file2.LastWriteTime.CompareTo(file1.LastWriteTime);
                });
        }

        public static List<FileInfo> SortFilesByLastWriteTimeAsc(ref FileInfo[] files)
        {
            Array.Sort(files, CompareFilesByLastWriteTimeAsc);
            return new List<FileInfo>(files);
        }

        public static int CompareFilesByLastWriteTimeAsc(FileInfo file1, FileInfo file2)
        {
            return file1.LastWriteTime.CompareTo(file2.LastWriteTime);


        }

        //parts.Sort(delegate (Part x, Part y)
        //{
        //    if (x.PartName == null && y.PartName == null) return 0;
        //    else if (x.PartName == null) return -1;
        //    else if (y.PartName == null) return 1;
        //    else return x.PartName.CompareTo(y.PartName);
        //});
        #endregion

    }
}