using ICSharpCode.SharpZipLib.Zip;
using NLog;
using System;
using System.Diagnostics;
using System.IO;
using System.Net;

namespace SteamWare.IO
{
    /// <summary>
    /// Accesso in lettura e scrittura al filesystem per gestione files upload e download
    /// </summary>
    public class fileMover
    {
        #region Public Fields

        /// <summary>
        /// versione statica (singleton) del'oggetto fileMover
        /// </summary>
        public static fileMover obj = new fileMover();

        /// <summary>
        /// oggetto WebClient
        /// </summary>
        public WebClient WebCli;

        #endregion Public Fields

        #region Public Constructors

        /// <summary>
        /// inizializza il metodo alla cartella indicata
        /// </summary>
        /// <param name="_path"></param>
        /// <param name="_log">non serve +... x retrocompatibilità...</param>
        public fileMover(string _path, string _log)
        {
            if (Log == null)
            {
                Log = LogManager.GetCurrentClassLogger();
            }
            setDirs(_path);
            WebCli = new WebClient();
        }

        /// <summary>
        /// metodo di avvio empty
        /// </summary>
        public fileMover()
        {
            if (Log == null)
            {
                Log = LogManager.GetCurrentClassLogger();
            }
            WebCli = new WebClient();
        }

        #endregion Public Constructors

        #region Public Methods

        /// <summary>
        /// Effettua copia files da locale a rete con auth (Local 2 Network)...
        /// </summary>
        /// <param name="pathSource"></param>
        /// <param name="pathDest"></param>
        /// <param name="credentialsSource"></param>
        /// <param name="credentialsDest"></param>
        /// <param name="fileSource"></param>
        /// <param name="fileDest"></param>
        /// <returns></returns>
        public static bool copiaFileL2N(string pathSource, string pathDest, NetworkCredential credentialsDest, string fileSource, string fileDest)
        {
            bool fatto = false;
            Log.Info($"Richiesta trasferimento files: {pathSource}\\{fileSource} --> {pathDest}\\{fileDest}");
            try
            {
                using (new NetworkConnection(pathDest, credentialsDest))
                {
                    File.Copy($"{pathSource}\\{fileSource}", $"{pathDest}\\{fileDest}");
                    fatto = true;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione durante trasferimento files: {pathSource}\\{fileSource} --> {pathDest}\\{fileDest}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// Effettua copia files via rete con auth (Net 2 Net)...
        /// </summary>
        /// <param name="pathSource"></param>
        /// <param name="pathDest"></param>
        /// <param name="credentialsSource"></param>
        /// <param name="credentialsDest"></param>
        /// <param name="fileSource"></param>
        /// <param name="fileDest"></param>
        /// <returns></returns>
        public static bool copiaFileN2N(string pathSource, string pathDest, NetworkCredential credentialsSource, NetworkCredential credentialsDest, string fileSource, string fileDest)
        {
            bool fatto = false;
            Log.Info($"Richiesta trasferimento files: {pathSource}\\{fileSource} --> {pathDest}\\{fileDest}");
            try
            {
                using (new NetworkConnection(pathSource, credentialsSource))
                using (new NetworkConnection(pathDest, credentialsDest))
                {
                    File.Copy($"{pathSource}\\{fileSource}", $"{pathDest}\\{fileDest}");
                    fatto = true;
                }
            }
            catch (Exception exc)
            {
                Log.Error($"Eccezione durante trasferimento files: {pathSource}\\{fileSource} --> {pathDest}\\{fileDest}{Environment.NewLine}{exc}");
            }
            return fatto;
        }

        /// <summary>
        /// elimina la folder indicata
        /// </summary>
        /// <param name="PathOfDir2Delete">Path della fodler da eliminare</param>
        /// <param name="recursive">Indica se cancellare in modo ricorsivo</param>
        /// <returns></returns>
        public static bool deleteDir(string PathOfDir2Delete, bool recursive = true)
        {
            bool ret = true;
            try
            {
                if (Directory.Exists(PathOfDir2Delete))
                {
                    Directory.Delete(PathOfDir2Delete, recursive);
                }
            }
            catch (Exception ex)
            {
                ret = false;
                Log.Error($"Non sono riuscito ad eliminare la directory {PathOfDir2Delete} richiesta: eccezione {ex}");
            }
            return ret;
        }

        /// <summary>
        /// elimina il file indicato
        /// </summary>
        /// <param name="PathOfFile2Delete"></param>
        /// <returns></returns>
        public static bool deleteFile(string PathOfFile2Delete)
        {
            bool ret = true;
            try
            {
                if (File.Exists(PathOfFile2Delete))
                {
                    File.Delete(PathOfFile2Delete);
                }
            }
            catch (Exception ex)
            {
                ret = false;
                Log.Error(string.Format("Non sono riuscito ad eliminare file: eccezione {0}", ex));
            }
            return ret;
        }

        /// <summary>
        /// Copia il contenuto directory da From a To (opzionalmente in modo ricorsivo)...
        /// </summary>
        /// <param name="sourceDirName">Nome dir sorgente</param>
        /// <param name="destDirName">Nome dir destinazione</param>
        /// <param name="copySubDirs">Indica se copiare ricorsivamente</param>
        /// <param name="overwrite">Indica se sovrascrivere i dati (default = true)</param>
        /// <returns></returns>
        public static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs, bool overwrite = true)
        {
            // Get the subdirectories for the specified directory.
            DirectoryInfo dir = new DirectoryInfo(sourceDirName);

            if (!dir.Exists)
            {
                throw new DirectoryNotFoundException(
                    "Source directory does not exist or could not be found: "
                    + sourceDirName);
            }

            DirectoryInfo[] dirs = dir.GetDirectories();
            // If the destination directory doesn't exist, create it.
            if (!Directory.Exists(destDirName))
            {
                Directory.CreateDirectory(destDirName);
            }

            // Get the files in the directory and copy them to the new location.
            FileInfo[] files = dir.GetFiles();
            foreach (FileInfo file in files)
            {
                string temppath = Path.Combine(destDirName, file.Name);
                file.CopyTo(temppath, overwrite);
            }

            // If copying subdirectories, copy them and their contents to new location.
            if (copySubDirs)
            {
                foreach (DirectoryInfo subdir in dirs)
                {
                    string temppath = Path.Combine(destDirName, subdir.Name);
                    DirectoryCopy(subdir.FullName, temppath, copySubDirs);
                }
            }
        }

        /// <summary>
        /// esegue un comando in shell
        /// </summary>
        /// <param name="workDir"></param>
        /// <param name="Command"></param>
        /// <param name="Timeout"></param>
        /// <returns></returns>
        public static int ExecuteCommand(string workDir, string Command, int Timeout)
        {
            int ExitCode;
            ProcessStartInfo ProcessInfo;
            Process Process;

            ProcessInfo = new ProcessStartInfo(Command);
            ProcessInfo.CreateNoWindow = false;
            ProcessInfo.UseShellExecute = true;
            ProcessInfo.WorkingDirectory = workDir;
            //ProcessInfo.RedirectStandardError = true;
            //ProcessInfo.RedirectStandardInput = true;
            //ProcessInfo.RedirectStandardOutput = true;
            Process = Process.Start(ProcessInfo);
            Process.WaitForExit(Timeout);
            ExitCode = Process.ExitCode;
            Process.Close();

            return ExitCode;
        }

        /// <summary>
        /// restituisce la stringa completa e corretta del filepath del server (anche con vDir)
        /// </summary>
        /// <param name="pathRel">path relativo alla cartella iis dell'applicativo</param>
        /// <returns>path fisico tradotto</returns>
        public static string getFilePath(string pathRel)
        {
            return System.Web.HttpContext.Current.Server.MapPath(pathRel);
        }

        /// <summary>
        /// esegue un comando in shell
        /// </summary>
        /// <param name="workDir"></param>
        /// <param name="Command"></param>
        /// <param name="Timeout"></param>
        /// <returns></returns>
        public static void LaunchCommand(string workDir, string Command, int Timeout)
        {
            //int ExitCode;
            ProcessStartInfo ProcessInfo;
            Process Process;

            ProcessInfo = new ProcessStartInfo(Command);
            ProcessInfo.CreateNoWindow = false;
            ProcessInfo.UseShellExecute = true;
            ProcessInfo.WorkingDirectory = workDir;
            //ProcessInfo.RedirectStandardError = true;
            //ProcessInfo.RedirectStandardInput = true;
            //ProcessInfo.RedirectStandardOutput = true;
            Process = Process.Start(ProcessInfo);
            //Process.WaitForExit(Timeout);
            //ExitCode = Process.ExitCode;
            //Process.Close();
        }

        /// <summary>
        /// Legge i dati da uno stream fino a quando arriva alla fine. I dati sono restituiti come
        /// un byte[] array. un eccezione IOException è sollevata se una delle chiamate IO
        /// sottostanti fallisce.
        /// </summary>
        /// <param name="stream">Lo stream da cui leggere</param>
        /// <param name="initialLength">Lunghezza buffer iniziale (-1 = default 32k)</param>
        public static byte[] ReadFully(Stream stream, int initialLength)
        {
            // If we've been passed an unhelpful initial length, just use 32K.
            if (initialLength < 1)
            {
                initialLength = 32768;
            }

            byte[] buffer = new byte[initialLength];
            int read = 0;

            int chunk;
            while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0)
            {
                read += chunk;

                // If we've reached the end of our buffer, check to see if there's any more information
                if (read == buffer.Length)
                {
                    int nextByte = stream.ReadByte();

                    // End of stream? If so, we're done
                    if (nextByte == -1)
                    {
                        return buffer;
                    }

                    // Nope. Resize the buffer, put in the byte we've just read, and continue
                    byte[] newBuffer = new byte[buffer.Length * 2];
                    Array.Copy(buffer, newBuffer, buffer.Length);
                    newBuffer[read] = (byte)nextByte;
                    buffer = newBuffer;
                    read++;
                }
            }
            // Buffer is now too big. Shrink it.
            byte[] ret = new byte[read];
            Array.Copy(buffer, ret, read);
            return ret;
        }

        /// <summary>
        /// scompatta tutto il contenuto di un file zip
        /// </summary>
        /// <param name="InputPathOfZipFile"></param>
        /// <returns></returns>
        public static bool UnZipFile(string InputPathOfZipFile)
        {
            bool ret = true;
            try
            {
                if (File.Exists(InputPathOfZipFile))
                {
                    string baseDirectory = Path.GetDirectoryName(InputPathOfZipFile);

                    using (ZipInputStream ZipStream = new

          ZipInputStream(File.OpenRead(InputPathOfZipFile)))
                    {
                        ZipEntry theEntry;
                        while ((theEntry = ZipStream.GetNextEntry()) != null)
                        {
                            if (theEntry.IsFile)
                            {
                                if (theEntry.Name != "")
                                {
                                    string strNewFile = @"" + baseDirectory + @"\" +

                  theEntry.Name;
                                    if (File.Exists(strNewFile))
                                    {
                                        continue;
                                    }

                                    using (FileStream streamWriter = File.Create(strNewFile))
                                    {
                                        int size = 4096;
                                        byte[] data = new byte[4096];
                                        while (true)
                                        {
                                            size = ZipStream.Read(data, 0, data.Length);
                                            if (size > 0)
                                                streamWriter.Write(data, 0, size);
                                            else
                                                break;
                                        }
                                        streamWriter.Close();
                                    }
                                }
                            }
                            else if (theEntry.IsDirectory)
                            {
                                string strNewDirectory = @"" + baseDirectory + @"\" + theEntry.Name;
                                if (!Directory.Exists(strNewDirectory))
                                {
                                    Directory.CreateDirectory(strNewDirectory);
                                }
                            }
                        }
                        ZipStream.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                ret = false;
                Log.Error(string.Format("Non sono riuscito ad unzippare: eccezione {0}", ex));
            }
            return ret;
        }

        /// <summary>
        /// scompatta uno specifico file contenuto in un file zip
        /// </summary>
        /// <param name="InputPathOfZipFile">The input path of zip file.</param>
        /// <param name="file2unzip">The file2unzip.</param>
        /// <returns></returns>
        public static bool UnZipSingleFile(string InputPathOfZipFile, string file2unzip)
        {
            bool ret = true;
            try
            {
                if (File.Exists(InputPathOfZipFile))
                {
                    string baseDirectory = Path.GetDirectoryName(InputPathOfZipFile);

                    using (ZipInputStream ZipStream = new

          ZipInputStream(File.OpenRead(InputPathOfZipFile)))
                    {
                        ZipEntry theEntry;
                        while ((theEntry = ZipStream.GetNextEntry()) != null)
                        {
                            if (theEntry.IsFile)
                            {
                                if (theEntry.Name == file2unzip)
                                {
                                    string strNewFile = @"" + baseDirectory + @"\" + theEntry.Name;
                                    if (File.Exists(strNewFile))
                                    {
                                        continue;
                                    }

                                    using (FileStream streamWriter = File.Create(strNewFile))
                                    {
                                        int size = 4096;
                                        byte[] data = new byte[4096];
                                        while (true)
                                        {
                                            size = ZipStream.Read(data, 0, data.Length);
                                            if (size > 0)
                                                streamWriter.Write(data, 0, size);
                                            else
                                                break;
                                        }
                                        streamWriter.Close();
                                    }
                                }
                            }
                            else if (theEntry.IsDirectory)
                            {
                                string strNewDirectory = @"" + baseDirectory + @"\" +

                theEntry.Name;
                                if (!Directory.Exists(strNewDirectory))
                                {
                                    Directory.CreateDirectory(strNewDirectory);
                                }
                            }
                        }
                        ZipStream.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                ret = false;
                Log.Error(string.Format("Non sono riuscito ad unzippare: eccezione {0}", ex));
            }
            return ret;
        }

        /// <summary>
        /// verifica esistenza directory, eventualmente crea e restituisce controllo DirectoryInfo
        /// </summary>
        /// <returns></returns>
        public DirectoryInfo checkDir()
        {
            DirectoryInfo _di = getDirectoryInfo();
            if (!_di.Exists)
            {
                _di.Create();
            }
            return _di;
        }

        /// <summary>
        /// copia il file da From a To...
        /// </summary>
        /// <param name="_pathFrom"></param>
        /// <param name="_pathTo"></param>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public bool copiaFile(string _pathFrom, string _pathTo, string _nomeFile)
        {
            bool fatto = false;
            // verifica directory
            _pathFrom = verDir(_pathFrom);
            _pathTo = verDir(_pathTo);
            FileInfo _fi = getFileInfoByName(_pathFrom, _nomeFile);
            try
            {
                _fi.CopyTo(_pathTo + _nomeFile, true);
                fatto = true;
            }
            catch (Exception e)
            {
                Console.WriteLine("{0} Exception caught.", e);
            }
            return fatto;
        }

        /// <summary>
        /// copia il file da From a To...
        /// </summary>
        /// <param name="_pathFrom"></param>
        /// <param name="_pathTo"></param>
        /// <param name="_nomeFileOrig"></param>
        /// <param name="_nomeFileDest"></param>
        /// <returns></returns>
        public bool copiaFile(string _pathFrom, string _pathTo, string _nomeFileOrig, string _nomeFileDest)
        {
            bool fatto = false;
            // verifica directory
            _pathFrom = verDir(_pathFrom);
            _pathTo = verDir(_pathTo);
            FileInfo _fi = getFileInfoByName(_pathFrom, _nomeFileOrig);
            try
            {
                _fi.CopyTo(System.Web.HttpContext.Current.Server.MapPath(_pathTo) + _nomeFileDest, true);
                fatto = true;
            }
            catch (Exception e)
            {
                Console.WriteLine("{0} Exception caught.", e);
                _fi.CopyTo(_pathTo + _nomeFileDest, true);
                fatto = true;
            }
            return fatto;
        }

        /// <summary>
        /// elimina il file + vecchio
        /// </summary>
        /// <returns></returns>
        public void deleteOldest()
        {
            DirectoryInfo _di = checkDir();
            FileInfo[] _fis = _di.GetFiles();
            DateTime _oldest = DateTime.Now;
            string _nome = "";
            foreach (FileInfo _file in _fis)
            {
                if (_file.CreationTime < _oldest)
                {
                    _nome = _file.Name;
                }
            }
            eliminaFile(_nome);
        }

        /// <summary>
        /// ottiene il dataset dei files presenti nella directory indicata all'istanziazione dell'oggetto
        /// </summary>
        /// <returns></returns>
        public DataLayer_generic.filesDataTable elencoFiles()
        {
            DirectoryInfo _di = checkDir();
            FileInfo[] _files = _di.GetFiles();
            DataLayer_generic.filesDataTable _dsEF = tabellaFiles(_files);
            return _dsEF;
        }

        /// <summary>
        /// ottiene il dataset dei files DEL TIPO "like {param}" presenti nella directory indicata
        /// all'istanziazione dell'oggetto
        /// </summary>
        /// <returns></returns>
        public DataLayer_generic.filesDataTable elencoFiles(string _param)
        {
            DirectoryInfo _di = checkDir();
            FileInfo[] _files = _di.GetFiles(_param);
            DataLayer_generic.filesDataTable _dsEF = tabellaFiles(_files);
            return _dsEF;
        }

        /// <summary>
        /// elenco dei files come array di oggetti FileInfo
        /// </summary>
        /// <returns></returns>
        public FileInfo[] elencoFiles_FI()
        {
            DirectoryInfo _di = checkDir();
            return _di.GetFiles();
        }

        /// <summary>
        /// elenco dei files come array di oggetti FileInfo filtrati per parametro
        /// </summary>
        /// <param name="_param"></param>
        /// <returns></returns>
        public FileInfo[] elencoFiles_FI(string _param)
        {
            DirectoryInfo _di = checkDir();
            return _di.GetFiles(_param);
        }

        /// <summary>
        /// ottiene il dataset dei files presenti nella directory indicata esplicitamente
        /// </summary>
        /// <param name="directory">
        /// dir da indicizzare... già mappata! ( es SteamwareStrings.getFilePath(...) )
        /// </param>
        /// <returns></returns>
        public DataLayer_generic.filesDataTable elencoFilesDir(string directory)
        {
            _workPath = directory;
            return elencoFiles();
        }

        /// <summary>
        /// elenco sub-directory array di oggetti FileInfo filtrati per parametro
        /// </summary>
        /// <returns></returns>
        public DirectoryInfo[] elencoSubdir_DI()
        {
            DirectoryInfo _di = checkDir();
            return _di.GetDirectories();
        }

        /// <summary>
        /// elenco sub-directory array di oggetti FileInfo filtrati per parametro
        /// </summary>
        /// <param name="_param"></param>
        /// <returns></returns>
        public DirectoryInfo[] elencoSubdir_DI(string _param)
        {
            DirectoryInfo _di = checkDir();
            return _di.GetDirectories(_param);
        }

        /// <summary>
        /// elimina la directory di lavoro se è dir virtuale mappata
        /// </summary>
        /// <returns></returns>
        public bool eliminaDir()
        {
            DirectoryInfo _di = checkDir();
            bool fatto = false;
            try
            {
                _di.Delete(true);
                fatto = true;
            }
            catch
            {
            }
            return fatto;
        }

        /// <summary>
        /// elimina il file indicato dalla directory di lavoro
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public bool eliminaFile(string _nomeFile)
        {
            FileInfo _fi = getFileInfoByName(_nomeFile);
            bool fatto = false;
            try
            {
                _fi.Delete();
                fatto = true;
            }
            catch
            { }
            if (fatto)
            {
                Log.Info($"Eliminazione file {_nomeFile} eseguita");
            }
            else
            {
                Log.Info($"impossibile Eliminare il file {_nomeFile}");
            }
            return fatto;
        }

        /// <summary>
        /// elimina il file indicato dalla directory di lavoro
        /// </summary>
        /// <param name="_fi">The _fi.</param>
        /// <returns></returns>
        public bool eliminaFile(FileInfo _fi)
        {
            bool fatto = false;
            try
            {
                _fi.Delete();
                fatto = true;
            }
            catch
            {
            }
            return fatto;
        }

        /// <summary>
        /// verifica se il file indicato esista in workDir
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public bool fileExist(string _nomeFile)
        {
            bool answ = false;
            FileInfo _fi = getFileInfoByName(_nomeFile);
            answ = _fi.Exists;
            if (!answ)
            {
                // registro che non ho trovaot il file: path e nome file!
                Log.Info(string.Format("Attenzione: non e' stato possibile trovare il file!{0}wrkDir:{1}{0}file:{2}", Environment.NewLine, _workPath, _nomeFile));
            }
            return answ;
        }

        /// <summary>
        /// verifica se il file indicato esista in _path
        /// </summary>
        /// <param name="_path"></param>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public bool fileExist(string _path, string _nomeFile)
        {
            bool answ = false;
            FileInfo _fi = getFileInfoByName(_path, _nomeFile);
            answ = _fi.Exists;
            if (!answ)
            {
                // registro che non ho trovaot il file: path e nome file!
                Log.Info(string.Format("Attenzione: non e' stato possibile trovare il file!{0}path:{1}{0}file:{2}", Environment.NewLine, _path, _nomeFile));
            }
            return answ;
        }

        /// <summary>
        /// sposta il file da From a To...
        /// </summary>
        /// <param name="_pathFrom"></param>
        /// <param name="_pathTo"></param>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public bool muoviFile(string _pathFrom, string _pathTo, string _nomeFile)
        {
            bool fatto = false;
            // verifica directory
            _pathTo = verDir(_pathTo);
            _pathFrom = verDir(_pathFrom);
            FileInfo _fi = getFileInfoByName(_pathFrom, _nomeFile, true);
            try
            {
                _fi.CopyTo(_pathTo + _nomeFile, true);
                _fi.Delete();
                fatto = true;
            }
            catch (Exception e)
            {
                Console.WriteLine("{0} Exception caught.", e);
            }
            return fatto;
        }

        /// <summary>
        /// scrive il file dallo stream byte[] inviato
        /// </summary>
        /// <param name="_path"></param>
        /// <param name="_nomeFile"></param>
        /// <param name="_fileBuffer"></param>
        /// <returns></returns>
        public bool salvaFileBuffer(string _path, string _nomeFile, byte[] _fileBuffer)
        {
            _workPath = _path;
            DirectoryInfo _di = getDirectoryInfo(_path, true);
            if (!_di.Exists)
            {
                _di.Create();
            }
            FileInfo _fi = getFileInfoByName(_path, _nomeFile);
            Stream _stream;
            if (!_fi.Exists)
            {
                _stream = _fi.Create();
            }
            else
            {
                _stream = _fi.OpenWrite();
            }
            _stream.Write(_fileBuffer, 0, _fileBuffer.Length);
            _stream.Flush();
            _stream.Close();

            return true;
        }

        /// <summary>
        /// scrive il file dallo stream byte[] inviato
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <param name="_fileBuffer"></param>
        /// <returns></returns>
        public bool salvaFileBuffer(string _nomeFile, byte[] _fileBuffer)
        {
            DirectoryInfo _di = getDirectoryInfo();
            if (!_di.Exists)
            {
                _di.Create();
            }
            FileInfo _fi = getFileInfoByName(_nomeFile);
            Stream _stream;
            if (!_fi.Exists)
            {
                _stream = _fi.Create();
            }
            else
            {
                _stream = _fi.OpenWrite();
            }
            _stream.Write(_fileBuffer, 0, _fileBuffer.Length);
            _stream.Flush();
            _stream.Close();

            return true;
        }

        /// <summary>
        /// scrive il file dalla stringa inviata
        /// </summary>
        /// <param name="_path"></param>
        /// <param name="_nomeFile"></param>
        /// <param name="_fileString"></param>
        /// <returns></returns>
        public bool salvaFileString(string _path, string _nomeFile, string _fileString)
        {
            return salvaFileBuffer(_path, _nomeFile, strToByte(_fileString));
        }

        /// <summary>
        /// scrive il file dalla stringa inviata
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <param name="_fileString"></param>
        /// <returns></returns>
        public bool salvaFileString(string _nomeFile, string _fileString)
        {
            return salvaFileBuffer(_nomeFile, strToByte(_fileString));
        }

        /// <summary>
        /// restituisce lo stream del file richiesto
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public byte[] scaricaFile(string _nomeFile)
        {
            FileInfo _fi = getFileInfoByName(_nomeFile);
            // verifica ci siano attach...
            if (_fi.Exists)
            {
                Stream _stream = _fi.OpenRead();
                byte[] _risposta = ReadFully(_stream, -1);
                _stream.Close();
                return _risposta;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Scarica un file dall'url fornito nella directory indicata x il filemover col nome richiesto
        /// </summary>
        /// <param name="urlFile">url del file</param>
        /// <param name="nomeDest">nome con cui salvare il file</param>
        /// <returns></returns>
        public void scaricaFileFromWeb(string urlFile, string nomeDest)
        {
            // utilizzo l'oggetto webCli...

            WebCli.Credentials = System.Net.CredentialCache.DefaultCredentials;
            WebCli.DownloadFile(urlFile, string.Format("{0}\\{1}", _workPath, nomeDest));
        }

        /// <summary>
        /// restituisce la stringa letta dal file richiesto
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public string scaricaFileString(string _nomeFile)
        {
            return byteToStr(scaricaFile(_nomeFile));
        }

        /// <summary>
        /// imposta la dir di lavoro
        /// </summary>
        /// <param name="_path"></param>
        public void setDirectory(string _path)
        {
            setDirs(_path);
        }

        /// <summary>
        /// imposta la dir di lavoro
        /// </summary>
        /// <param name="_path"></param>
        /// <param name="_log">non serve +... x retrocompatibilità...</param>
        public void setDirectory(string _path, string _log)
        {
            setDirs(_path);
        }

        /// <summary>
        /// imposta la dir di lavoro impostandola dal mapPath corretto della web app... (come
        /// subfolder della web app)
        /// </summary>
        /// <param name="_path"></param>
        public void setDirectoryMapPath(string _path)
        {
            setDirs(System.Web.HttpContext.Current.Server.MapPath(_path));
        }

        /// <summary>
        /// elimina tutti i files con la regexp indicata da una directory, true se cancellato almeno uno
        /// </summary>
        /// <param name="nomeCercato">regexp selezione files in dir (* = tutti!!!)</param>
        /// <returns></returns>
        public bool svuotaDir(string nomeCercato)
        {
            bool answ = false;
            FileInfo[] _fis = elencoFiles_FI(nomeCercato);
            foreach (FileInfo _file in _fis)
            {
                eliminaFile(_file.Name);
                answ = true;
            }
            return answ;
        }

        /// <summary>
        /// calcola la dim della directory corrente...
        /// </summary>
        /// <returns></returns>
        public float totalMb()
        {
            DirectoryInfo _di = checkDir();
            FileInfo[] _fis = _di.GetFiles();
            float _byte = 0;
            foreach (FileInfo _file in _fis)
            {
                _byte += _file.Length;
            }
            return _byte / 1000000;
        }

        /// <summary>
        /// comprime zip i files corrispondenti alla RegExp indicata nella dir corrente
        /// </summary>
        /// <param name="regExp">Espressione ricerca, come *.txt</param>
        /// <param name="outZipFileName">Nome del file zip da creare</param>
        /// <returns></returns>
        public bool zippaFilesByRegExp(string regExp, string outZipFileName)
        {
            bool fatto = false;
            // inizializzo il file zip...
            DirectoryInfo _di = checkDir();
            // calcolo il nome del file zip...
            string nomeZip = string.Format("{0}/{1}.zip", _di.FullName, outZipFileName.Replace(".zip", ""));
            // inizio a inserire dati
            try
            {
                using (ZipOutputStream s = new ZipOutputStream(File.Create(nomeZip)))
                {
                    s.SetLevel(5);
                    byte[] buffer = new byte[4096];
                    // effettuo una ricerca dei files corrispondenti al criterio regexp, e per
                    // ognuno effettuo inserimento in zipfile...
                    FileInfo[] filesTrovati = elencoFiles_FI(regExp);
                    ZipEntry entry;
                    foreach (FileInfo _fi in filesTrovati)
                    {
                        // calcolo la nuova entry nel file zip...
                        entry = new ZipEntry(Path.GetFileName(_fi.FullName));
                        // Could also use the last write time or similar for the file.
                        entry.DateTime = DateTime.Now;
                        s.PutNextEntry(entry);
                        using (FileStream fs = File.OpenRead(_fi.FullName))
                        {
                            // Using a fixed size buffer here makes no noticeable difference for
                            // output but keeps a lid on memory usage.
                            int sourceBytes;
                            do
                            {
                                sourceBytes = fs.Read(buffer, 0, buffer.Length);
                                s.Write(buffer, 0, sourceBytes);
                            } while (sourceBytes > 0);
                        }
                    }
                    s.Finish();
                    s.Close();
                }
                fatto = true;
            }
            catch (Exception e)
            {
                Log.Error(string.Format("Errore in creazione file zip con parametri {0} e {1}: {2}", regExp, outZipFileName, e));
            }
            return fatto;
        }

        /// <summary>
        /// comprime zip il file indicato
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        public bool zippaSingoloFile(string _nomeFile)
        {
            bool fatto = false;
            FileInfo _fi = getFileInfoByName(_nomeFile);
            // calcolo il nome del file zip...
            string nomeZip = string.Format("{0}.zip", _fi.FullName);
            try
            {
                using (ZipOutputStream s = new ZipOutputStream(File.Create(nomeZip)))
                {
                    s.SetLevel(5);
                    byte[] buffer = new byte[4096];
                    ZipEntry entry = new ZipEntry(Path.GetFileName(_fi.FullName));
                    // Could also use the last write time or similar for the file.
                    entry.DateTime = DateTime.Now;
                    s.PutNextEntry(entry);
                    using (FileStream fs = File.OpenRead(_fi.FullName))
                    {
                        // Using a fixed size buffer here makes no noticeable difference for output
                        // but keeps a lid on memory usage.
                        int sourceBytes;
                        do
                        {
                            sourceBytes = fs.Read(buffer, 0, buffer.Length);
                            s.Write(buffer, 0, sourceBytes);
                        } while (sourceBytes > 0);
                    }
                    s.Finish();
                    s.Close();
                }
                fatto = true;
            }
            catch
            {
            }
            return fatto;
        }

        /// <summary>
        /// comprime zip il file indicato
        /// </summary>
        /// <param name="_fi">File in formato FileInfo</param>
        /// <returns></returns>
        public bool zippaSingoloFile(FileInfo _fi)
        {
            bool fatto = false;
            // calcolo il nome del file zip...
            string nomeZip = string.Format("{0}.zip", _fi.FullName);
            try
            {
                using (ZipOutputStream s = new ZipOutputStream(File.Create(nomeZip)))
                {
                    s.SetLevel(5);
                    byte[] buffer = new byte[4096];
                    ZipEntry entry = new ZipEntry(Path.GetFileName(_fi.FullName));
                    // Could also use the last write time or similar for the file.
                    entry.DateTime = DateTime.Now;
                    s.PutNextEntry(entry);
                    using (FileStream fs = File.OpenRead(_fi.FullName))
                    {
                        // Using a fixed size buffer here makes no noticeable difference for output
                        // but keeps a lid on memory usage.
                        int sourceBytes;
                        do
                        {
                            sourceBytes = fs.Read(buffer, 0, buffer.Length);
                            s.Write(buffer, 0, sourceBytes);
                        } while (sourceBytes > 0);
                    }
                    s.Finish();
                    s.Close();
                }
                fatto = true;
            }
            catch
            {
            }
            return fatto;
        }

        #endregion Public Methods

        #region Protected Fields

        /// <summary>
        /// path di lavoro dei metodi leggi/scrivi
        /// </summary>
        protected string _workPath;

        #endregion Protected Fields

        #region Protected Methods

        /// <summary>
        /// converte un byte[] in una string
        /// </summary>
        /// <param name="_array"></param>
        /// <returns></returns>
        protected string byteToStr(byte[] _array)
        {
            System.Text.ASCIIEncoding encod = new System.Text.ASCIIEncoding();
            return encod.GetString(_array);
        }

        /// <summary>
        /// Recupera path correttamente (se fisico o virtuale
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        protected string GetPath(string path)
        {
            if (Path.IsPathRooted(path))
            {
                return path;
            }
            // altrimenti MapPath!
            return System.Web.HttpContext.Current.Server.MapPath(path);
        }

        /// <summary>
        /// converte una string in un byte[]
        /// </summary>
        /// <param name="_val"></param>
        /// <returns></returns>
        protected byte[] strToByte(string _val)
        {
            System.Text.ASCIIEncoding encod = new System.Text.ASCIIEncoding();
            return encod.GetBytes(_val);
        }

        /// <summary>
        /// verifica esistenza directory ed eventualmente crea restituendo nome completo di "/" finale
        /// </summary>
        /// <param name="_path"></param>
        /// <returns></returns>
        protected string verDir(string _path)
        {
            DirectoryInfo di = getDirectoryInfo(_path, true);
            if (!di.Exists)
            {
                di.Create();
            }
            if (!_path.EndsWith("/") && !_path.EndsWith(@"\"))
            {
                _path += "/";
            }
            return _path;
        }

        #endregion Protected Methods

        #region Private Fields

        private static NLog.Logger Log = LogManager.GetCurrentClassLogger();

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// restituisce una tab di files dato l'elenco dei files
        /// </summary>
        /// <param name="_files"></param>
        /// <returns></returns>
        private static DataLayer_generic.filesDataTable tabellaFiles(FileInfo[] _files)
        {
            DataLayer_generic.filesDataTable _dsEF = new DataLayer_generic.filesDataTable();
            DataLayer_generic.filesRow _riga;
            foreach (FileInfo _fi in _files)
            {
                _riga = _dsEF.NewfilesRow();
                _riga.dataCreaz = _fi.CreationTime;
                _riga.dataMod = _fi.LastWriteTime;
                _riga.Nome = _fi.Name;
                _riga.size = _fi.Length / 1000;
                _dsEF.AddfilesRow(_riga);
            }
            return _dsEF;
        }

        /// <summary>
        /// cerca di caricare la directoryInfo o da httpcontext-application re-position o
        /// direttamente come workpath
        /// </summary>
        /// <returns></returns>
        private DirectoryInfo getDirectoryInfo()
        {
            DirectoryInfo _di;
            try
            {
                _di = new DirectoryInfo(System.Web.HttpContext.Current.Server.MapPath(_workPath));
            }
            catch
            {
                _di = new DirectoryInfo(_workPath);
            }
            return _di;
        }

        /// <summary>
        /// imposta la directory richiesta...
        /// </summary>
        /// <returns></returns>
        private DirectoryInfo getDirectoryInfo(string path, bool absPath)
        {
            DirectoryInfo _di;
            if (absPath)
            {
                _di = new DirectoryInfo(path);
            }
            else
            {
                try
                {
                    _di = new DirectoryInfo(System.Web.HttpContext.Current.Server.MapPath(path));
                }
                catch
                {
                    _di = new DirectoryInfo(path);
                }
            }
            return _di;
        }

        /// <summary>
        /// cerca di caricare il fileinfo o da httpcontext-application re-position o direttamente
        /// come workpath + nomefile
        /// </summary>
        /// <param name="_nomeFile"></param>
        /// <returns></returns>
        private FileInfo getFileInfoByName(string _nomeFile)
        {
            FileInfo _fi;
            try
            {
                _fi = new FileInfo(GetPath(_workPath + "\\" + _nomeFile));
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in recupero info file: {_nomeFile}{Environment.NewLine}{exc}");
                _fi = new FileInfo(_workPath + "\\" + _nomeFile);
            }
            return _fi;
        }

        /// <summary>
        /// cerca di caricare il fileinfo o da httpcontext-application re-position o direttamente
        /// come workpath + nomefile
        /// </summary>
        /// <param name="_path">The _path.</param>
        /// <param name="_nomeFile">The _nome file.</param>
        /// <returns></returns>
        private FileInfo getFileInfoByName(string _path, string _nomeFile)
        {
            FileInfo _fi;
            try
            {
                _fi = new FileInfo(GetPath(_path + _nomeFile));
            }
            catch (Exception exc)
            {
                Log.Error($"Errore in recupero info path: {_path} | file: {_nomeFile}{Environment.NewLine}{exc}");
                _fi = new FileInfo(_path + "\\" + _nomeFile);
            }
#if false
      try
      {
        _fi = new FileInfo(System.Web.HttpContext.Current.Server.MapPath(_path + _nomeFile));
      }
      catch
      {
        _fi = new FileInfo(_path + "\\" + _nomeFile);
      }
#endif
            return _fi;
        }

        /// <summary>
        /// cerca di caricare il fileinfo o da httpcontext-application re-position o direttamente
        /// come workpath + nomefile
        /// </summary>
        /// <param name="_path">cartella file</param>
        /// <param name="_nomeFile">nome file</param>
        /// <param name="absPath">indica se il path sia assoluto</param>
        /// <returns></returns>
        private FileInfo getFileInfoByName(string _path, string _nomeFile, bool absPath)
        {
            FileInfo _fi;
            if (absPath)
            {
                _fi = new FileInfo(_path + "\\" + _nomeFile);
            }
            else
            {
                _fi = getFileInfoByName(_path, _nomeFile);
            }
            return _fi;
        }

        /// <summary>
        /// setta le directory
        /// </summary>
        /// <param name="_path"></param>
        private void setDirs(string _path)
        {
            _workPath = _path;
        }

        #endregion Private Methods
    }
}