/**

  * Copyright 2008 WebPhotos

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package net.sf.webphotos.sync.FTP;

 import java.io.File;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.StringTokenizer;

 import net.sf.webphotos.Album;

 import net.sf.webphotos.BancoImagem;

 import net.sf.webphotos.PhotoDTO;

 import net.sf.webphotos.sync.Sync;

 import net.sf.webphotos.sync.SyncEvent;

 import net.sf.webphotos.sync.SyncException;

 import net.sf.webphotos.sync.SyncListener;

 import net.sf.webphotos.util.Util;

 import net.sf.webphotos.util.legacy.Arquivo;

 import net.sf.webphotos.util.legacy.CacheFTP;

 import net.sf.webphotos.util.legacy.ComandoFTP;

 import org.apache.commons.net.ftp.FTPClient;

 import org.apache.commons.net.ftp.FTPClientConfig;

 import org.apache.commons.net.ftp.FTPReply;

 import org.apache.commons.net.io.CopyStreamListener;

 import org.apache.log4j.Logger;

 /**

  * Interface entre o sistema e o envio de arquivos. Herda a classe FTPClient e

  * implementa (sobrescreve) os métodos da interface Sync. Possui métodos de

  * transferência de arquivos, mudança de diretório, criação de subdiretório,

  * conexão e desconexão ao FTP e carregamento de arquivos de FTP.

  *

  * @author guilherme

  */

 public class SyncObject extends FTPClient implements Sync {

     private int reply;

     private ArrayList<Arquivo> listaArquivos = new ArrayList<Arquivo>();

     private String ftpRoot = null;

     private List listFTP;

     private File albunsRoot = Util.getAlbunsRoot();

     private String usuario;

     private char[] senha;

     private long totalBytes = 0;

     private long transmitido = 0;

     private boolean enviarAltaResolucao;

     private SyncListener syncListener = null;

     private CopyStreamListener copyStreamListener = null;

     private String ftpHost;

     private int ftpPort;

     private int retry;

     private static final Logger log = Logger.getLogger(SyncObject.class);

     /**

      * Cria uma nova instância de FTP

      */

     public SyncObject() {

         super();

         enviarAltaResolucao = Util.getProperty("enviarAltaResolucao").equals("true");

     }

     /**

      * Método baseado no storeFile da classe FTPClient, do pacote commons/net.

      * Acrescenta um controle de processamento para saber quanto foi

      * enviado/recebido.

      *

      * @param streamOrigem Arquivo de origem

      * @param streamDestino Local de destino

      * @param streamSize Tamanho do arquivo

      * @throws java.io.IOException Problemas na leitura e escrita dos dados.

      */

     @Override

     public void transferFile(InputStream streamOrigem, OutputStream streamDestino, long streamSize)

             throws IOException {

         org.apache.commons.net.io.Util.copyStream(

                 streamOrigem,

                 streamDestino,

                 getBufferSize(),

                 streamSize,

                 copyStreamListener,

                 true);

         streamDestino.flush();

         streamOrigem.close();

         streamDestino.close();

         completePendingCommand();

     }

     /**

      * Muda de diretório. criando o diretório quando não existir. TODO: Colocar

      * o Util.log para trabalhar no fluxo de execução.

      *

      * @param diretorioFilho Diretório que deve ser acessado.

      * @throws net.sf.webphotos.sync.SyncException Erro de sincronização.

      * @throws java.io.IOException Erro de comunicação entre os dados.

      */

     @Override

     public void cd(String diretorioFilho) throws IOException, SyncException {

         changeWorkingDirectory(getSyncFolder());

         Util.out.println(printWorkingDirectory());

         changeWorkingDirectory(diretorioFilho);

         if (getReplyCode() != FTPReply.CODE_250) {

             Util.log(getSyncFolder() + File.separator + diretorioFilho + " não existe..criando");

             if (!makeDirectory(diretorioFilho)) {

                 throw new SyncException("[FTP.cd]/ERRO: não foi possível criar diretório " + diretorioFilho + " verifique suas permissões com o provedor");

             }

         }

         pwd();

         Util.log("ok cd " + printWorkingDirectory());

     }

     /**

      * Cria um novo subdiretório no servidor FTP, no diretório atual (se um

      * pathname relativo é dado) ou onde especificado (se um pathname absoluto é

      * dado). Esta é uma versão recurssiva que cria os diretórios somente quando

      * são precisos.

      *

      * @param pathName O nome do diretório a ser criado.

      * @return True se completou com sucesso, ou false caso não.

      * @exception IOException Se um erro de I/O ocorrer enquanto está enviando

      * comando para o servidor ou recebendo resposta dele.

      */

     @Override

     public boolean makeDirectory(String pathName) throws IOException {

         if (pathName.startsWith("/")) {

             changeWorkingDirectory("/");

             pathName = pathName.substring(1);

         }

         Util.out.println(super.printWorkingDirectory());

         String[] dirs = pathName.split("/");

         for (String dir : dirs) {

             if (!super.printWorkingDirectory().endsWith(dir)) {

                 super.changeWorkingDirectory(dir);

                 if (!FTPReply.isPositiveCompletion(super.getReplyCode())) {

                     super.makeDirectory(dir);

                     super.changeWorkingDirectory(dir);

                     if (!FTPReply.isPositiveCompletion(super.getReplyCode())) {

                         return false;

                     }

                 }

             }

         }

         return (getReplyCode() == FTPReply.CODE_250 || getReplyCode() == FTPReply.CODE_250);

     }

     /**

      * Conecta ao servidor FTP. Retorna uma confirmação da conexão através de um

      * boolean. TODO: remontar a função para que use somente dados externos a

      * classe

      *

      * @return Valor lógico que confirma a conexão.

      */

     @Override

     public boolean connect() {

         boolean conectado = false;

         ftpHost = Util.getProperty("servidorFTP");

         ftpPort = Util.getConfig().getInt("FTPport");

         String ftpProxyHost = Util.getProperty("FTPproxyHost");

         int ftpProxyPort;

         try {

             ftpProxyPort = Util.getConfig().getInt("FTPproxyPort");

         } catch (Exception e) {

             ftpProxyPort = 0;

         }

         Util.log("Iniciando conexão com " + ftpHost);

         try {

             //TODO: Preparar o suporte a múltiplas línguas

             FTPClientConfig auxConfig = new FTPClientConfig(FTPClientConfig.SYST_NT);

             configure(auxConfig);

             Util.out.println("Timeout (antes): " + getDefaultTimeout());

             setDefaultTimeout(25000);

             Util.out.println("Timeout (depois): " + getDefaultTimeout());

             //TODO: Testar o acesso via Proxy

             //      usando System.getProperties().put()

             //      http://java.sun.com/j2se/1.5.0/docs/guide/net/properties.html

             if (ftpProxyHost == null && ftpProxyPort != 0) {

                 System.getProperties().put("ftp.proxyHost", ftpProxyHost);

                 System.getProperties().put("ftp.proxyPort", ftpProxyPort);

             }

             super.connect(ftpHost, ftpPort);

             reply = getReplyCode();

             if (!FTPReply.isPositiveCompletion(reply)) {

                 disconnect("[FtpClient.connect]/ERRO: não foi possivel conectar");

                 return false;

             }

             Util.log("ok " + ftpHost + " encontrado.. autenticando..");

             SyncEvent ev = null;

             if (syncListener != null) {

                 ev = new SyncEvent(this);

             }

             reply = FTPReply.NOT_LOGGED_IN;

             do {

                 if (syncListener != null && ev != null) {

                     syncListener.logonStarted(ev);

                 }

                 Util.log("servidor: " + ftpHost + " em " + ftpRoot + "\nsolicitando conexão...");

                 login(usuario, new String(senha));

                 Util.log("usuário: " + usuario + " senha: ***");

                 reply = getReplyCode();

                 retry--;

             } while (reply != FTPReply.USER_LOGGED_IN && retry >= 0);

             if (reply != FTPReply.USER_LOGGED_IN) {

                 disconnect("[FtpClient.connect]/ERRO: login/senha incorreto.");

                 return conectado;

             } else {

                 // conexão bem sucedida... armazenamos o nome/login

                 BancoImagem.getBancoImagem().setUserFTP(getUsuario());

                 BancoImagem.getBancoImagem().setPasswordFTP(getSenha());

             }

             Util.log("ok conexão aceita..");

             // autenticação ok..

             setFileType(FTPClient.BINARY_FILE_TYPE);

             //ftp.enterRemotePassiveMode();

             // TODO: Achar uma alternativa para realizar o logging do FTP

             //ftp.setLogFile("ftp.log");

             // tenta ir ao diretório FTPRoot... caso não consiga, tenta criar

             changeWorkingDirectory(ftpRoot);

             if (getReplyCode() != FTPReply.CODE_250) {

                 Util.log(ftpRoot + " não existe..criando");

                 if (makeDirectory(ftpRoot)) {

                     Util.log("[FtpClient.connect]/ERRO: não foi possível criar diretório " + ftpRoot + " Retorno: " + reply);

                     disconnect("não foi possível criar diretório");

                     return conectado;

                 }

                 changeWorkingDirectory(ftpRoot);

                 reply = getReplyCode();

                 if (reply != FTPReply.CODE_250) {

                     disconnect("[FtpClient.connect]/ERRO: não foi possível entrar no diretório " + ftpRoot + " que foi recém criado.");

                     return conectado;

                 }

             }

             conectado = true;

             getSyncListener().connected(new SyncEvent(this));

         } catch (Exception e) {

             conectado = false;

             log.error(e);

             disconnect("[FtpClient.connect]/ERRO: não foi possivel manter esta conexão");

         }

         return conectado;

     }

     /**

      * Desconecta do servidor FTP e apresenta uma mensagem de log.

      *

      * @param msg Mensagem de desconexão.

      */

     @Override

     public void disconnect(String msg) {

         try {

             Util.log("Desconectando (" + msg + ") ok");

             super.disconnect();

         } catch (Exception e) {

             Util.log("Erro ao tentar desconectar.");

         } finally {

             Util.log(msg);

             try {

                 // ao finalizar, verificar se houve erros

                 // arquivos com status <> "ok -..." serão re-enfileirados

                 Iterator iter = listFTP.iterator();

                 while (iter.hasNext()) {

                     Arquivo a = new Arquivo((List) iter.next());

                     //Arquivo a=(Arquivo) iter.next();

                     if (!a.getStatus().startsWith("ok")) {

                         CacheFTP.getCache().addCommand(a.getAcao(), a.getAlbumID(), a.getFotoID());

                     }

                 }// fim while

             } catch (Exception e) {

             }

             // Dispara o evento de desconnectado

             if (syncListener != null) {

                 syncListener.disconnected(new SyncEvent(this));

             }

         }

     }

     /**

      * Faz um load no ArrayList CacheFTP, faz uma busca por iteração, identifica

      * e carrega as linhas de comandos na seguinte ordem: DELETE, UPLOAD e

      * DOWNLOAD. Carrega esses comandos através do método

      * {@link net.sf.webphotos.sync.FTP.SyncObject#loadSyncCacheLine() loadSyncCacheLine}().

      * Por último, após completo o load, limpa a lista do CacheFTP.

      */

     @Override

     public void loadSyncCache() {

         Iterator<ComandoFTP> i = CacheFTP.getCache().iterator();

         String linha;

         Util.out.println("Numero de linhas: " + CacheFTP.getCache().toString());

         // primeiro delete                

         while (i.hasNext()) {

             linha = i.next().toString();

             if (linha.startsWith("3")) {

                 loadSyncCacheLine(linha);

             }

         }

         // depois upload

         i = CacheFTP.getCache().iterator();

         while (i.hasNext()) {

             linha = i.next().toString();

             if (linha.startsWith("1")) {

                 loadSyncCacheLine(linha);

             }

         }

         // depois download

         i = CacheFTP.getCache().iterator();

         while (i.hasNext()) {

             linha = i.next().toString();

             if (linha.startsWith("2")) {

                 loadSyncCacheLine(linha);

             }

         }

         // limpa o CacheFTP

         CacheFTP.getCache().clear();

     }

     /**

      * Recebe uma linha com comando de FTP (DELETE, DOWNLOAD ou UPLOAD),

      * processa o tipo "acao albumID foto" e a carrega em cima do ArrayList

      * listaArquivos, que contém dados de

      * {@link net.sf.webphotos.util.Arquivo Arquivo}.

      *

      * @param linha Linha de comando FTP.

      */

     @Override

     public void loadSyncCacheLine(String linha) {

         StringTokenizer tok = new StringTokenizer(linha);

         int acao = -1;

         int albumID = -1;

         int fotoID = -1;

         Util.out.println("carrega: " + linha);

         if (tok.countTokens() == 3) {

             acao = Integer.parseInt(tok.nextToken());

             albumID = Integer.parseInt(tok.nextToken());

             fotoID = Integer.parseInt(tok.nextToken());

         } else {

             // houve um erro...

             Util.out.println("erro: " + linha);

             return;

         }

         // obtem uma lista do álbum (todos os arquivos)

         File f = new File(getAlbunsRoot(), Integer.toString(albumID));

         String[] ls = f.list();

         switch (acao) {

             // Apagar

             case CacheFTP.DELETE:

             // Receber

             case CacheFTP.DOWNLOAD:

                 if (fotoID == 0) {

                     // O álbum inteiro

                     listaArquivos.add(new Arquivo(linha, acao, albumID, 0, "* todos"));

                 } else {

                     // Uma foto

                     listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_a" + fotoID + ".jpg"));

                     listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_b" + fotoID + ".jpg"));

                     listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_c" + fotoID + ".jpg"));

                     listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_d" + fotoID + ".jpg"));

                     if (isEnviarAltaResolucao() == true) {

                         listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, fotoID + ".jpg"));

                         listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, fotoID + ".zip"));

                     }

                     listaArquivos.add(new Arquivo(linha, acao, albumID, 0, albumID + ".xml"));

                     listaArquivos.add(new Arquivo(linha, acao, albumID, 0, albumID + ".js"));

                 }

                 break;

             // Enviar

             case CacheFTP.UPLOAD:

                 if (fotoID == 0) {

                     // O álbum inteiro

                     Album.getAlbum().loadAlbum(albumID);

                     for (PhotoDTO atual : Album.getAlbum().getFotos()) {

                         fotoID = atual.getFotoID();

                         listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_a" + fotoID + ".jpg"));

                         listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_b" + fotoID + ".jpg"));

                         listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_c" + fotoID + ".jpg"));

                         listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, "_d" + fotoID + ".jpg"));

                         if (isEnviarAltaResolucao() == true) {

                             listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, fotoID + ".jpg"));

                             listaArquivos.add(new Arquivo(linha, acao, albumID, fotoID, fotoID + ".zip"));

                         }

                     }

                     listaArquivos.add(new Arquivo(linha, acao, albumID, 0, albumID + ".xml"));

                     listaArquivos.add(new Arquivo(linha, acao, albumID, 0, albumID + ".js"));

                 } else {

                     // Uma foto

                     Util.out.println("Upload alta: " + isEnviarAltaResolucao());

                     for (String fileName : ls) {

                         if ((fileName.startsWith("_") && fileName.toLowerCase().endsWith(fotoID + ".jpg"))

                                 || (isEnviarAltaResolucao() && fileName.toLowerCase().endsWith(fotoID + ".zip"))

                                 || (isEnviarAltaResolucao() && fileName.toLowerCase().endsWith(fotoID + ".jpg"))) {

                             Arquivo a = new Arquivo(linha, acao, albumID, fotoID, fileName);

                             listaArquivos.add(a);

                         }

                     } // fim for

                 }

                 break;

         }

     }

     /**

      * Retorna o caminho que deve usar

      *

      * @return Mostra o caminho base

      */

     @Override

     public String getSyncFolder() {

         return ftpRoot;

     }

     /**

      * Determina qual caminho usar

      *

      * @param ftpRoot Parâmetro que recebe a informação

      */

     @Override

     public void setSyncFolder(String ftpRoot) {

         this.ftpRoot = ftpRoot;

     }

     /**

      * Retorna o ouvinte syncListener.

      *

      * @return Retorna um listener de sincronização.

      */

     @Override

     public SyncListener getSyncListener() {

         return syncListener;

     }

     /**

      * Seta o ouvinte syncListener.

      *

      * @param listener Um listener de sincronização.

      */

     @Override

     public void setSyncListener(SyncListener listener) {

         this.syncListener = listener;

     }

     /**

      * Retorna o objeto copyStreamListener.

      *

      * @return Retorna copyStreamListener.

      */

     @Override

     public CopyStreamListener getCopyStreamListener() {

         return copyStreamListener;

     }

     /**

      * Seta o objeto copyStreamListener.

      *

      * @param copyStreamListener Objeto da classe CopyStreamListener.

      */

     @Override

     public void setCopyStreamListener(CopyStreamListener copyStreamListener) {

         this.copyStreamListener = copyStreamListener;

     }

     /**

      * Retorna o usuário.

      *

      * @return Retorna um usuário.

      */

     @Override

     public String getUsuario() {

         return usuario;

     }

     /**

      * Seta um nome para usuário.

      *

      * @param usuario Usuário.

      */

     @Override

     public void setUsuario(String usuario) {

         this.usuario = usuario;

     }

     /**

      * Retorna a senha do usuário.

      *

      * @return Retorna uma senha.

      */

     @Override

     public char[] getSenha() {

         return senha;

     }

     /**

      * Seta uma senha para o usuário.

      *

      * @param senha Senha do usuário.

      */

     @Override

     public void setSenha(char[] senha) {

         this.senha = senha;

     }

     /**

      * Retorna o ArrayList listaArquivos.

      *

      * @return Retorna listaArquivos.

      */

     @Override

     public ArrayList<Arquivo> getListaArquivos() {

         return listaArquivos;

     }

     /**

      * Seta uma lista para a variável listaArquivos.

      *

      * @param _listaArquivos Lista de arquivos.

      */

     public void setListaArquivos(ArrayList<Arquivo> _listaArquivos) {

         this.listaArquivos = _listaArquivos;

     }

     /**

      * Retorna o valor de enviarAltaResolucao. Especifica se serão enviadas ou

      * não, as imagens originais.

      *

      * @return Retorna um valor lógico.

      */

     @Override

     public boolean isEnviarAltaResolucao() {

         return enviarAltaResolucao;

     }

     /**

      * Retorna o diretório raiz de albúns. TODO: Já existe um método igual a

      * esse na classe Util.

      *

      * @return Retorna um diretório.

      */

     public File getAlbunsRoot() {

         return albunsRoot;

     }

 }