//
// SwitchRMI  Framework
// Copyright (c) 2000-2002 by Michael J. Henderson & Associates.
//
// Michael Henderson
// mailto:mikehenderson@dunelm.org.uk
//
// This library is free software.
//
// You may redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License as published by the Free Software Foundation.
//
// Version 2.1 of the license should be included with this distribution in
// the file LICENSE, as well as License.html. If the license is not
// included with this distribution, you may find a copy at the FSF web
// site at 'www.gnu.org' or 'www.fsf.org', or you may write to the
// Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139 USA.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied waranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// $Id: SmtpClientTransport.java,v 1.1 2002/11/11 22:19:48 mikehenderson Exp $
package com.mjh.switchrmi.transport.smtp;

import com.mjh.switchrmi.*;
import com.mjh.util.*;

import java.io.*;

import java.net.MalformedURLException;

import java.util.*;

import javax.activation.*;

import javax.mail.*;
import javax.mail.internet.*;

import org.apache.log4j.Logger;

/**
 * @author michaelh
 *
 * To change this generated comment edit the template variable "typecomment":
 * Window>Preferences>Java>Templates.
 * To enable and disable the creation of type comments go to
 * Window>Preferences>Java>Code Generation.
 */
public class SmtpClientTransport
    extends RmiTransportBase
{
    private static final Logger log = 
            Logger.getLogger(SmtpClientTransport.class.getName());
    private ByteArrayOutputStream out;
    private String mimeType;
    private UrlInfo urlInfo;

    /**
     * Constructor for SmtpClientTransport.
     */
    public SmtpClientTransport()
    {
        super.setType(RmiTransport.ASYNCHRONOUS);
        super.setName("smtp-client");
    }

    /**
     * @see com.mjh.switchrmi.RmiTransport#getOutputStream()
     */
    public OutputStream getOutputStream(RmiContext context)
        throws IOException
    {
        System.out.println("getOutputStream()");

        if (out == null)
        {
            out = new ByteArrayOutputStream();
        }

        return out;
    }

    byte[] getBytes()
    {
        return out.toByteArray();
    }

    public String getMimeType()
    {
        return mimeType;
    }

    private String getCleanUrl()
    {
        String url = "smtp:" + urlInfo.getHost()
                     + ((urlInfo.getPort() != 0) ? (":" + urlInfo.getPort()) : "")
                     + urlInfo.getPath();

        return url;
    }

    protected String getUserName()
    {
        String user = (String) urlInfo.getParameterValue("user");

        System.out.println("user = " + user);

        return user;
    }

    protected String getPassword()
    {
        String password = (String) urlInfo.getParameterValue("password");

        System.out.println("password = " + password);

        return password;
    }

    public UrlInfo getUrlInfo(RmiContext context)
                       throws MalformedURLException
    {
        return new UrlInfo(context.getUrl(), new String[] { "from", "to" });
    }

    private Properties makeSessionProperties(UrlInfo urlInfo)
    {
        Properties p = new Properties();

        p.setProperty("mail.transport.protocol", urlInfo.getProtocol());
        p.setProperty("mail.host", urlInfo.getHost());

        String user = urlInfo.getParameterValue("user");

        if (user != null)
        {
            p.setProperty("mail.user", user);
            p.setProperty("mail.smtp.auth", "true");
        }

        return p;
    }

    /**
     * @see com.mjh.switchrmi.RmiTransport#send()
     */
    public void send(RmiContext context)
              throws Exception
    {
        urlInfo = context.getUrlInfo();

        // looks for mail.smtp.host set in system properties
        Properties sessionProps = makeSessionProperties(urlInfo);

        System.out.println("sessionProps = " + sessionProps);

        Authenticator auth = null;

        if (urlInfo.getParameterValue("user") != null)
        {
            auth = new SmtpAuthenticator();
        }

        System.out.println("auth = " + auth);

        Session session = Session.getInstance(sessionProps, auth);

        if (log.isDebugEnabled())
        {
            session.setDebug(true);
        }

        session.setDebug(true);

        mimeType = context.getProtocol().getMimeType();

        InternetAddress from = 
                new InternetAddress(urlInfo.getParameterValue("from"));
        InternetAddress[] to = 
                InternetAddress.parse(urlInfo.getParameterValue("to"));

        Message message = new MimeMessage(session);

        message.setFrom(from);
        message.setRecipients(Message.RecipientType.TO, to);
        message.setSubject(
                "SwitchRMI Remote Method Invocation Request Attached To This Message");

        Multipart multipart = new MimeMultipart();
        MimeBodyPart body = new MimeBodyPart();

        body.setContent(getCleanUrl(), "text/plain");

        MimeBodyPart attachment = new MimeBodyPart();

        attachment.setDataHandler(new DataHandler(new SmtpDataSource()));

        multipart.addBodyPart(body);
        multipart.addBodyPart(attachment);

        message.setContent(multipart);

        Transport.send(message);
    }

    private String getObjectName()
    {
        return "SwitchRMI-over-SMTP";
    }

    class SmtpAuthenticator extends Authenticator
    {
        protected PasswordAuthentication getPasswordAuthentication()
        {
            return new PasswordAuthentication(
                           SmtpClientTransport.this.getUserName(), 
                           SmtpClientTransport.this.getPassword());
        }
    }

    class SmtpDataSource implements DataSource
    {
        public SmtpDataSource()
        {
        }

        public String getContentType()
        {
            String type = SmtpClientTransport.this.getMimeType();

            System.out.println("SmtpDataSource.getContentType() = " + type);

            return type;
        }

        public String getName()
        {
            String name = SmtpClientTransport.this.getObjectName();

            System.out.println("SmtpDataSource.getName() = " + name);

            return name;
        }

        public InputStream getInputStream()
            throws IOException
        {
            byte[] bytes = SmtpClientTransport.this.getBytes();

            System.out.println("SmtpDataSource.getInputStream() bytes = "
                               + new String(bytes));

            return new ByteArrayInputStream(bytes);
        }

        public OutputStream getOutputStream()
            throws IOException
        {
            System.out.println("SmtpDataSource.getInputStream() out = "
                               + "null");

            return null;
        }
    }
}