package com.hfg.util.io;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPClientConfig;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPHTTPClient;
import org.apache.commons.net.ftp.FTPReply;

import com.hfg.security.LoginCredentials;
import com.hfg.units.TimeUnit;

//------------------------------------------------------------------------------
/**
 * Delineates FTP files matching the specified path. If behind a firewall that
 * requires the use of proxies, you will need to set <code>socksProxyHost</code>
 * and <code>socksProxyPort</code> (Jakarta's commons-net which is used for FTP
 * uses sockets). See <a href='http://java.sun.com/j2se/1.4.2/docs/guide/net/properties.html'>
 * http://java.sun.com/j2se/1.4.2/docs/guide/net/properties.html</a> for proxy details.
 * <p>
 * This class depends on Jakarta's commons-net library (which depends on jakarta-oro).
 * </p>
 * @author J. Alex Taylor, hairyfatguy.com
 */
//------------------------------------------------------------------------------
// com.hfg XML/HTML Coding Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// jataylor@hairyfatguy.com
//------------------------------------------------------------------------------


public class FTPRemoteFileLister  extends AbstractRemoteFileLister<FTPRemoteFile>
{

   //***************************************************************************
   // PRIVATE FIELDS
   //***************************************************************************

   private List<FTPRemoteFile> mRemoteFiles;

   private String       mFTPServer;
   private Integer      mFTPPort;
   private String       mProxyHost;
   private Integer      mProxyPort = 80;
   private String       mProxyUser;
   private String       mProxyPassword;

   private List<String> mFilePathPieces;
   private FTPClient    mFTP;

   private static final String PROTOCOL = "ftp";
   private static LoginCredentials sDefaultCredentials = new LoginCredentials("anonymous", getUserAtHostPassword().toCharArray());

   //***************************************************************************
   // CONSTRUCTORS
   //***************************************************************************

   //---------------------------------------------------------------------------
   public FTPRemoteFileLister()
   {
      super();
      init();
   }

   //---------------------------------------------------------------------------
   public FTPRemoteFileLister(String inFilePath)
   {
      super(inFilePath);
      init();
   }

   //---------------------------------------------------------------------------
   public FTPRemoteFileLister(String inFilePath, List<RemoteFileFilter> inFilterList)
   {
      super(inFilePath, inFilterList);
      init();
   }

   //---------------------------------------------------------------------------
   private void init()
   {
      setCredentials(sDefaultCredentials);
   }

   //***************************************************************************
   // PUBLIC METHODS
   //***************************************************************************

   //---------------------------------------------------------------------------
   @Override
   public String getProtocol()
   {
      return PROTOCOL;
   }

   //---------------------------------------------------------------------------
   @Override
   public void setFilePath(String inFilePath)
   {
      super.setFilePath(inFilePath);
      mRemoteFiles = null;
   }

   //---------------------------------------------------------------------------
   public FTPClient getFTPClient()
   {
      if (null == mFTP
          || ! mFTP.isConnected())
      {
         if (null == getCredentials())
         {
            throw new RuntimeException("No login credentials specified!?");
         }

         if (mProxyHost != null)
         {
            mFTP = new FTPHTTPClientWrapper(mProxyHost, mProxyPort, mProxyUser, mProxyPassword);
         }
         else
         {
            mFTP = new FTPClientWrapper();
         }

         mFTP.setRemoteVerificationEnabled(false); // Bad with caching firewalls
         mFTP.setDataTimeout((int)TimeUnit.hour.getMilliseconds());

         try
         {
            int reply;
            if (mFTPPort != null)
            {
               mFTP.connect(mFTPServer, mFTPPort);
            }
            else
            {
               mFTP.connect(mFTPServer);
            }

            // After connection attempt, check the reply code to verify success.
            reply = mFTP.getReplyCode();

            if(! FTPReply.isPositiveCompletion(reply))
            {
               throw new RuntimeException("FTP server '" + mFTPServer + "' refused connection.");
            }

            mFTP.login(getCredentials().getUser(), new String(getCredentials().getPassword()));

            // Hmmm. Data connections on my mac never seem to go anywhere unless I do this to force passive mode.
            mFTP.enterLocalPassiveMode();
         }
         catch(IOException e)
         {
            if(mFTP.isConnected())
            {
               try
               {
                  mFTP.disconnect();
               }
               catch(IOException f)
               {
                  // do nothing
               }
            }

            throw new RuntimeException(e);
         }
      }

      return mFTP;
   }


   //---------------------------------------------------------------------------
   public void clearRemoteFileList()
   {
      mRemoteFiles = null;
   }

   //---------------------------------------------------------------------------
   public void logout()
   throws IOException
   {
      if (mFTP != null) mFTP.logout();
   }


   //---------------------------------------------------------------------------
   public FTPRemoteFileLister setProxyHost(String inValue)
   {
      mProxyHost = null;
      if (inValue != null)
      {
         if (inValue.indexOf(":") > 0)
         {
            String[] pieces = inValue.split(":");
            mProxyHost = pieces[0];
            setProxyPort(Integer.parseInt(pieces[1]));
         }
         else
         {
            mProxyHost = inValue;
         }
      }
      return this;
   }

   //---------------------------------------------------------------------------
   public String getProxyHost()
   {
      return mProxyHost;
   }

   //---------------------------------------------------------------------------
   public FTPRemoteFileLister setProxyPort(int inValue)
   {
      mProxyPort = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public Integer getProxyPort()
   {
      return mProxyPort;
   }

   //---------------------------------------------------------------------------
   public FTPRemoteFileLister setProxyUser(String inValue)
   {
      mProxyUser = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public String getProxyUser()
   {
      return mProxyUser;
   }

   //---------------------------------------------------------------------------
   public FTPRemoteFileLister setProxyPassword(String inValue)
   {
      mProxyPassword = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   public String getProxyPassword()
   {
      return mProxyPassword;
   }

   //***************************************************************************
   // PROTECTED METHODS
   //***************************************************************************

   //---------------------------------------------------------------------------
   protected List<FTPRemoteFile> getUnfilteredRemoteFileListImpl()
   {
      if (null == mRemoteFiles)
      {
        mFilePathPieces = splitFilePath();

        // "" instead of "/" to start the recursion seems to cause trouble for some FTP servers.
//        mRemoteFiles = recursiveFileLister(0, "");
        mRemoteFiles = recursiveFileLister(0, "/");
      }

      return mRemoteFiles;
   }

   //***************************************************************************
   // PRIVATE METHODS
   //***************************************************************************

   //---------------------------------------------------------------------------
   private static String getUserAtHostPassword()
   {
      String passwd;
      try
      {
         passwd = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
      }
      catch (UnknownHostException e)
      {
         throw new RuntimeException(e);
      }

      return passwd;
   }

   //---------------------------------------------------------------------------
   private List<String> splitFilePath()
   {
      // Remove 'ftp://'
      String url = getFilePath().substring(6);
      int index = url.indexOf("/");

      // Remove (and save) the FTP server name
      mFTPServer = url.substring(0, index);

      int colonIndex = mFTPServer.indexOf(":");
      if (colonIndex > 0)
      {
         mFTPPort = new Integer(mFTPServer.substring(colonIndex + 1));
         mFTPServer = mFTPServer.substring(0, colonIndex);
      }

      url = url.substring(index + 1);

      StringTokenizer st = new StringTokenizer(url, "/");

      List<String> pieces = new ArrayList<String>();
      while (st.hasMoreTokens())
      {
         pieces.add(st.nextToken());
      }

      return pieces;
   }

   //---------------------------------------------------------------------------
   private List<FTPRemoteFile> recursiveFileLister(int inLevel, String inFilePath)
   {
      List<FTPRemoteFile> remoteFiles = new ArrayList<>();

      if (!getFTPClient().isConnected()) throw new RuntimeException("Client not connected!");

      try
      {
         if (inLevel < mFilePathPieces.size())
         {
            String levelString = mFilePathPieces.get(inLevel);

            // Wildcard?
            if (levelString.contains("*"))
            {
               // Get a list of the current dir.
               FTPFile ftpFiles[] = getFTPClient().listFiles(inFilePath);
               checkReplyCode("listFiles('" + inFilePath + "')");

               if (ftpFiles != null)
               {
                  for (FTPFile file : ftpFiles)
                  {
                     if (file.isSymbolicLink()
                           && file.getName().equals(inFilePath))
                     {
                        String adjustedFilePath = inFilePath.substring(0, inFilePath.lastIndexOf("/")) + "/" + file.getLink();
                        remoteFiles.addAll(recursiveFileLister(inLevel, adjustedFilePath));
                     }
                     else if (wildcardMatch(levelString, file.getName()))
                     {
                        if (inLevel == mFilePathPieces.size() - 1)
                        {
                           remoteFiles.add(new FTPRemoteFile(mFTP, mFTPServer, inFilePath, file));
                        }
                        else
                        {
                           String filePath = inFilePath + "/" + file.getName();
                           remoteFiles.addAll(recursiveFileLister(inLevel + 1, filePath));
                        }
                     }
                  }
               }
            }
            else
            {
               if (inLevel == mFilePathPieces.size() - 1)
               {
                  // Get a list of the current dir.
                  FTPFile ftpFiles[] = getFTPClient().listFiles(inFilePath);
                  checkReplyCode("listFiles('" + inFilePath + "')");

                  if (ftpFiles != null)
                  {
                     for (FTPFile file : ftpFiles)
                     {
                        if (file != null  // Not sure why, but the file is sometimes null
                            && levelString.equals(file.getName()))
                        {
                           if (file.isDirectory())
                           {
                              // Want to list the contents of the directory
                              mFilePathPieces.add("*");
                              String filePath = inFilePath + (inLevel > 0 ? "/" : "") + levelString;
                              remoteFiles.addAll(recursiveFileLister(inLevel + 1, filePath));
                           }
                           else
                           {
                              if (file.getLink() != null)
                              {
                                 // Symbolic link.
                                 // If we don't resolve the link, the correct file will get downloaded
                                 // but the size won't match the size of the symbolic link.
                                 FTPRemoteFile remoteFile = resolveLink(inFilePath, file)
                                       .setRequestedPath(inFilePath + "/" + file.getName());
                                 remoteFiles.add(remoteFile);
                              }
                              else
                              {
                                 remoteFiles.add(new FTPRemoteFile(mFTP, mFTPServer, inFilePath, file));
                              }
                           }
                           break;
                        }
                     }
                  }
               }
               else
               {
                  String filePath = inFilePath + (inLevel > 0 ? "/" : "") + levelString;
                  remoteFiles.addAll(recursiveFileLister(inLevel + 1, filePath));
               }
            }

         }
      }
      catch (IOException e)
      {
         throw new RuntimeException(e);
      }

      return remoteFiles;
   }


   //---------------------------------------------------------------------------
   private FTPRemoteFile resolveLink(String inFilePath, FTPFile inLink)
         throws IOException
   {
      String parentDirPath = inFilePath;
      FTPFile file = inLink;
      while (file.getLink() != null)
      {
         String filePath;
         if (file.getLink().startsWith("/"))
         {
            filePath = file.getLink();
         }
         else // relative path
         {
            String linkPath = file.getLink();
            while (linkPath.startsWith("."))
            {
               if (linkPath.startsWith("../"))
               {
                  parentDirPath = parentDirPath.substring(0, parentDirPath.lastIndexOf("/"));
                  linkPath = linkPath.substring(3);
               }
               else if (linkPath.startsWith("./"))
               {
                  linkPath = linkPath.substring(2);
               }
            }

            filePath = parentDirPath + "/" + linkPath;
         }

         file = getFTPClient().listFiles(filePath)[0];

         parentDirPath = filePath.substring(0, filePath.lastIndexOf("/"));
      }

      return new FTPRemoteFile(mFTP, mFTPServer, parentDirPath, file);
   }

   //---------------------------------------------------------------------------
   private void checkReplyCode(String inCmd)
   {
      int replyCode = getFTPClient().getReplyCode();
      if(!FTPReply.isPositiveCompletion(replyCode))
      {

         throw new RuntimeException(inCmd + " returned: " + getFTPClient().getReplyString() + "!");
      }
   }

   //***************************************************************************
   // INNER CLASS
   //***************************************************************************

   // What is this for? It seems that if I call setFileType() repeatedly, FTPClient
   // issues the FTP command even if the value of the file type did not change.
   // This is also true for changeWorkingDirectory().
   //---------------------------------------------------------------------------
   private class FTPClientWrapper extends FTPClient
   {
      private int    mFileType = Integer.MIN_VALUE;
      private String mConnectedHost;
      private String mCurrentWorkingDirectory;

      //---------------------------------------------------------------------------
      public FTPClientWrapper()
      {
         super();

         FTPClientConfig config = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
         // If the remote FTP server's time is slightly ahead of the local machine
         // it can cause confusion because the year isn't typically set and the
         // year will be guessed as last year.
         config.setLenientFutureDates(true);
         configure(config);
      }

      //---------------------------------------------------------------------------
      @Override
      public void connect(String inServer)
      throws IOException
      {
         mConnectedHost = inServer;
         super.connect(inServer);
      }

      //---------------------------------------------------------------------------
      public String getConnectedHostname()
      {
         return mConnectedHost;
      }

      //---------------------------------------------------------------------------
      @Override
      public boolean setFileType(int inValue)
      throws IOException
      {
         boolean result = true;
         if (mFileType != inValue)
         {
            result = super.setFileType(inValue);
            if (result)
            {
               mFileType = inValue;
            }
         }

         return result;
      }

      //---------------------------------------------------------------------------
      // There is no sense issuing a command to charge directories when we are already
      // in the requested directory.
      @Override
      public boolean changeWorkingDirectory(String pathname)
            throws IOException
      {
         boolean result = true;

         if (null == mCurrentWorkingDirectory
             || ! mCurrentWorkingDirectory.equals(pathname))
         {
            result = super.changeWorkingDirectory(pathname);
            if (result)
            {
               mCurrentWorkingDirectory = pathname;
            }
         }

         return result;
      }
   }

   //***************************************************************************
   // INNER CLASS
   //***************************************************************************

   // What is this for? It seems that if I call setFileType() repeatedly, FTPClient
   // issues the FTP command even if the value of the file type did not change.
   //---------------------------------------------------------------------------
   private class FTPHTTPClientWrapper extends FTPHTTPClient
   {
      private int    mFileType = Integer.MIN_VALUE;
      private String mConnectedHost;
      private String mCurrentWorkingDirectory;


      //---------------------------------------------------------------------------
      public FTPHTTPClientWrapper(String inProxyHost, int inProxyPort, String inProxyUser, String inProxyPassword)
      {
         super(inProxyHost, inProxyPort, inProxyUser, inProxyPassword);

         FTPClientConfig config = new FTPClientConfig(FTPClientConfig.SYST_UNIX);
         // If the remote FTP server's time is slightly ahead of the local machine
         // it can cause confusion because the year isn't typically set and the
         // year will be guessed as last year.
         config.setLenientFutureDates(true);
         configure(config);
      }

      //---------------------------------------------------------------------------
      @Override
      public void connect(String inServer)
      throws IOException
      {
         mConnectedHost = inServer;
         super.connect(inServer);
      }

      //---------------------------------------------------------------------------
      public String getConnectedHostname()
      {
         return mConnectedHost;
      }

      //---------------------------------------------------------------------------
      @Override
      public boolean setFileType(int inValue)
      throws IOException
      {
         boolean result = true;
         if (mFileType != inValue)
         {
            result = super.setFileType(inValue);
            mFileType = inValue;
         }

         return result;
      }

      //---------------------------------------------------------------------------
      // There is no sense issuing a command to charge directories when we are already
      // in the requested directory.
      @Override
      public boolean changeWorkingDirectory(String pathname)
            throws IOException
      {
         boolean result = true;

         if (null == mCurrentWorkingDirectory
             || ! mCurrentWorkingDirectory.equals(pathname))
         {
            result = super.changeWorkingDirectory(pathname);
            if (result)
            {
               mCurrentWorkingDirectory = pathname;
            }
         }

         return result;
      }
   }
}