using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;


public class FtpClient
{
    private string _host = null;
    private string _user = null;
    private string _pass = null;
    private FtpWebRequest ftpRequest = null;
    private FtpWebResponse ftpResponse = null;
    private Stream ftpStream = null;
    private int bufferSize = 2048;

    /* Construct Object */

    public FtpClient(string hostIp, string userName, string password)
    {
        _host = hostIp;
        _user = userName;
        _pass = password;
    }

    /* Download File */

    public void Download(string remoteFile, string localFile)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_host + "/" + remoteFile);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.DownloadFile;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Get the FTP Server's Response Stream */
        ftpStream = ftpResponse.GetResponseStream();
        /* Open a File Stream to Write the Downloaded File */
        FileStream localFileStream = new FileStream(localFile, FileMode.Create);
        /* Buffer for the Downloaded Data */
        byte[] byteBuffer = new byte[bufferSize];
        int bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
        /* Download the File by Writing the Buffered Data Until the Transfer is Complete */
        try
        {
            while (bytesRead > 0)
            {
                localFileStream.Write(byteBuffer, 0, bytesRead);
                bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        /* Resource Cleanup */
        localFileStream.Close();
        ftpStream.Close();
        ftpResponse.Close();
        ftpRequest = null;
        ftpResponse = null;
        ftpStream = null;
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        //return;
    }

    /* Upload File */

    public void Upload(string remoteFile, string localFile)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_host + remoteFile);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
        /* Establish Return Communication with the FTP Server */
        ftpStream = ftpRequest.GetRequestStream();
        /* Open a File Stream to Read the File for Upload */
        FileStream localFileStream = new FileStream(localFile, FileMode.Open);
        /* Buffer for the Downloaded Data */
        byte[] byteBuffer = new byte[bufferSize];
        int bytesSent = localFileStream.Read(byteBuffer, 0, bufferSize);
        /* Upload the File by Sending the Buffered Data Until the Transfer is Complete */
        try
        {
            while (bytesSent != 0)
            {
                ftpStream.Write(byteBuffer, 0, bytesSent);
                bytesSent = localFileStream.Read(byteBuffer, 0, bufferSize);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        /* Resource Cleanup */
        localFileStream.Close();
        ftpStream.Close();
        ftpRequest = null;
        ftpStream = null;
        //}
        //catch (Exception ex)
        //{
        //  Console.WriteLine(ex.ToString());
        //}
        //return;
    }

    /* Delete File */

    public void Delete(string deleteFile)
    {
        try
        {
            /* Create an FTP Request */
            ftpRequest = (FtpWebRequest)WebRequest.Create(_host + "/" + deleteFile);
            /* Log in to the FTP Server with the User Name and Password Provided */
            ftpRequest.Credentials = new NetworkCredential(_user, _pass);
            /* When in doubt, use these options */
            ftpRequest.UseBinary = true;
            ftpRequest.UsePassive = true;
            ftpRequest.KeepAlive = true;
            /* Specify the Type of FTP Request */
            ftpRequest.Method = WebRequestMethods.Ftp.DeleteFile;
            /* Establish Return Communication with the FTP Server */
            ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
            /* Resource Cleanup */
            ftpResponse.Close();
            ftpRequest = null;
            ftpResponse = null;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        return;
    }

    /* Rename File */

    public void Rename(string currentFileNameAndPath, string newFileName)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)WebRequest.Create(_host + "/" + currentFileNameAndPath);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.Rename;
        /* Rename the File */
        ftpRequest.RenameTo = newFileName;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Resource Cleanup */
        ftpResponse.Close();
        ftpRequest = null;
        ftpResponse = null;
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        //return;
    }

    /* Create a New Directory on the FTP Server */

    public void CreateDirectory(string newDirectory)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)WebRequest.Create(_host + "/" + newDirectory);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.MakeDirectory;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Resource Cleanup */
        ftpResponse.Close();
        ftpRequest = null;
        ftpResponse = null;
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        //return;
    }

    /* Create a New Directory on the FTP Server */

    public void RemoveDirectory(string directoryName)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)WebRequest.Create(_host + "/" + directoryName);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.RemoveDirectory;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Resource Cleanup */
        ftpResponse.Close();
        ftpRequest = null;
        ftpResponse = null;
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        //return;
    }


    /* Get the Date/Time a File was Created */

    public string GetFileCreatedDateTime(string fileName)
    {

        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_host + "/" + fileName);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.GetDateTimestamp;

        DateTime fileInfo = ((FtpWebResponse)ftpRequest.GetResponse()).LastModified;

        /////////////////////////////////
        /* comment by arian 9 seot 2015*/
        /////////////////////////////////
        /* Establish Return Communication with the FTP Server */
        //ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Establish Return Communication with the FTP Server */
        //ftpStream = ftpResponse.GetResponseStream();
        /* Get the FTP Server's Response Stream */
        //StreamReader ftpReader = new StreamReader(ftpStream);
        ///* Store the Raw Response */
        //string fileInfo = null;
        ///* Read the Full Response Stream */
        //try
        //{
        //    fileInfo = ftpReader.ReadToEnd();
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        ///* Resource Cleanup */
        //ftpReader.Close();
        /////////////////////////////////
        /* comment by arian 9 seot 2015*/
        /////////////////////////////////

        // ftpStream.Close();
        // ftpResponse.Close();
        ftpRequest = null;
        // ftpResponse = null;
        //ftpStream = null;
        /* Return File Created Date Time */
        return fileInfo.ToString();
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        /* Return an Empty string Array if an Exception Occurs */
        //return "";
    }

    /* Get the Size of a File */

    public string GetFileSize(string fileName)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_host + "/" + fileName);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.GetFileSize;

        var fileInfo = ((FtpWebResponse)ftpRequest.GetResponse()).ContentLength;

        /////////////////////////////////
        /* comment by arian 9 seot 2015*/
        /////////////////////////////////
        /* Establish Return Communication with the FTP Server */
        //ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Establish Return Communication with the FTP Server */
        //ftpStream = ftpResponse.GetResponseStream();
        /* Get the FTP Server's Response Stream */
        //StreamReader ftpReader = new StreamReader(ftpStream);
        ///* Store the Raw Response */
        //string fileInfo = null;
        ///* Read the Full Response Stream */
        //try
        //{
        //    while (ftpReader.Peek() != -1)
        //    {
        //        fileInfo = ftpReader.ReadToEnd();
        //    }
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        ///* Resource Cleanup */
        //ftpReader.Close();
        /////////////////////////////////
        /* comment by arian 9 seot 2015*/
        /////////////////////////////////



        //ftpStream.Close();
        //ftpResponse.Close();
        ftpRequest = null;
        // ftpResponse = null;
        //ftpStream = null;
        /* Return File Size */
        return fileInfo.ToString();
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        /* Return an Empty string Array if an Exception Occurs */
        //return "";
    }

    /* List Directory Contents File/Folder Name Only */

    public string[] DirectoryListSimple(string directory)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_host + "/" + directory);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Establish Return Communication with the FTP Server */
        ftpStream = ftpResponse.GetResponseStream();
        /* Get the FTP Server's Response Stream */
        StreamReader ftpReader = new StreamReader(ftpStream);
        /* Store the Raw Response */
        string directoryRaw = null;
        /* Read Each Line of the Response and Append a Pipe to Each Line for Easy Parsing */
        try
        {
            while (ftpReader.Peek() != -1)
            {
                directoryRaw += ftpReader.ReadLine() + "|";
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        /* Resource Cleanup */
        ftpReader.Close();
        ftpStream.Close();
        ftpResponse.Close();
        ftpRequest = null;
        ftpResponse = null;
        ftpStream = null;
        /* Return the Directory Listing as a string Array by Parsing 'directoryRaw' with the Delimiter you Append (I use | in This Example) */
        try
        {
            string[] directoryList = directoryRaw.Split("|".ToCharArray());
            return directoryList;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        ///* Return an Empty string Array if an Exception Occurs */
        return new string[] { "" };
    }

    /* List Directory Contents in Detail (Name, Size, Created, etc.) */

    public string[] DirectoryListDetailed(string directory)
    {
        //try
        //{
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(_host + "/" + directory);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(_user, _pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Establish Return Communication with the FTP Server */
        ftpStream = ftpResponse.GetResponseStream();
        /* Get the FTP Server's Response Stream */
        StreamReader ftpReader = new StreamReader(ftpStream);
        /* Store the Raw Response */
        string directoryRaw = null;
        /* Read Each Line of the Response and Append a Pipe to Each Line for Easy Parsing */
        try
        {
            while (ftpReader.Peek() != -1)
            {
                directoryRaw += ftpReader.ReadLine() + "|";
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        /* Resource Cleanup */
        ftpReader.Close();
        ftpStream.Close();
        ftpResponse.Close();
        ftpRequest = null;
        ftpResponse = null;
        ftpStream = null;
        /* Return the Directory Listing as a string Array by Parsing 'directoryRaw' with the Delimiter you Append (I use | in This Example) */
        try
        {
            string[] directoryList = directoryRaw.Split("|".ToCharArray());
            return directoryList;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
        //}
        //catch (Exception ex)
        //{
        //    Console.WriteLine(ex.ToString());
        //}
        ///* Return an Empty string Array if an Exception Occurs */
        return new string[] { "" };
    }
}