package com.sbk.common;

import java.io.Serializable;

public class SendMail  implements Serializable {

    private static final long serialVersionUID = 1L;

    public static final Config config = new Config();

    private static int HOST_NUMBER = 0;

    private Protocol m_log;

    private ArrayList<String> m_RecipientList;
    private String m_szSubject;
    private String m_szMessage = "";
    private String m_szSender;
    private ArrayList<String> m_attachments;

    public SendMail(ArrayList<String> aAddress, String szSubject, Protocol log)
    {
        m_log = new Protocol(log);

        m_RecipientList = aAddress;
        m_szSubject = szSubject;

        m_attachments = new ArrayList<String>();

        HOST_NUMBER++;
        if(HOST_NUMBER >= Config.m_EmailList.size())
            HOST_NUMBER = 0;

        m_szSender = Config.m_EmailList.get(HOST_NUMBER).getSenderAddress();
    }

    public boolean send(){

        m_log.SetWhere("SendMail.send");

        EMail myEmail = Config.m_EmailList.get(HOST_NUMBER);

        String szHost = myEmail.getSmtpHost();
        int iPort = myEmail.getSmtpPort();
        String szUserName = myEmail.getSmtpUser();
        String szPassword = myEmail.getSmtpPassword();

        Session mailSession = Session.getDefaultInstance(new Properties());
        Message myMessage = new MimeMessage(mailSession);

        try {
            myMessage.setFrom(new InternetAddress(this.m_szSender));
            ArrayList<String> aToAddress = this.m_RecipientList;
            for(int i = 0; i < aToAddress.size(); i++){
                if(i==0)
                    myMessage.addRecipient(RecipientType.TO, new InternetAddress(aToAddress.get(i)));
                else
                    myMessage.addRecipient(RecipientType.CC, new InternetAddress(aToAddress.get(i)));

            }

            myMessage.setSubject(this.m_szSubject);

            // Create a message part to represent the body text
            BodyPart messageBodyPart = new MimeBodyPart();
            messageBodyPart.setText(this.m_szMessage);

            //use a MimeMultipart as we need to handle the file attachments
            Multipart multipart = new MimeMultipart();

            //add the message body to the mime message
            multipart.addBodyPart(messageBodyPart);

            /*
            // add any file attachments to the message TODO: add attachment as file content
            Iterator<String> myAttachmentIterator = m_attachments.iterator();
            while (myAttachmentIterator.hasNext()) {
                String filename = myAttachmentIterator.next();
                MimeBodyPart attachmentBodyPart = new MimeBodyPart();

                //use a JAF FileDataSource as it does MIME type detection
                DataSource source = new FileDataSource(filename);
                attachmentBodyPart.setDataHandler(new DataHandler(source));

                //assume that the filename you want to send is the same as the
                //actual file name - could alter this to remove the file path
                attachmentBodyPart.setFileName(filename);

                //add the attachment
                multipart.addBodyPart(attachmentBodyPart);
            }
             */
            // Put all message parts in the message
            myMessage.setContent(multipart);

            System.out.println("SmtpHost: " + szHost);
            System.out.println("SmtpPort: " + iPort);
            System.out.println("szUserName: " + szUserName);
            System.out.println("szPassword: " + szPassword);

            Transport transport = mailSession.getTransport("smtp");
            try {
                transport.connect(szHost, iPort, szUserName, szPassword);
            } catch (AddressException e) {
                m_log.Log(Protocol.Code.INFO_CONFIG, "transport.connect", e.getMessage());
                return false;
            } catch (MessagingException e) {
                m_log.Log(Protocol.Code.INFO_CONFIG, "transport.connect failure [MessagingException]", e.getMessage());
                return false;
            }
            try {
            transport.sendMessage(myMessage, myMessage.getAllRecipients());
            } catch (AddressException e) {
                m_log.Log(Protocol.Code.INFO_CONFIG, "transport.sendMessage [AddressException]", e.getMessage());
                return false;
            } catch (MessagingException e) {
                m_log.Log(Protocol.Code.INFO_CONFIG, "transport.sendMessage [MessagingException]", e.getMessage());
                return false;
            }
            transport.close();

            m_log.Log(Protocol.Code.INFO_CONFIG, "Email(s) properly sent", "Count["+aToAddress.size()+"], Msg["+this.m_szMessage+"]");
            return true;

        } catch (AddressException e) {
            m_log.Log(Protocol.Code.INFO_CONFIG, "Email sending failure [AddressException]", e.getMessage());
            //e.printStackTrace();
        } catch (MessagingException e) {
            m_log.Log(Protocol.Code.INFO_CONFIG, "Email sending failure [MessagingException]", e.getMessage());
            //e.printStackTrace();
        }

        return false;
    }

    public void addMessage(String szMessage)
    {
        m_szMessage = szMessage + "\n";
    }

    public void addAddress(String szAddress)
    {
        this.m_RecipientList.add(szAddress);
    }

    public void removeAddress(String szAddress)
    {
        this.m_RecipientList.remove(szAddress);
    }

    public void setSubject(String m_szSubject) {
        this.m_szSubject = m_szSubject;
    }
    public String getSubject() {
        return m_szSubject;
    }
    public void setMessage(String m_szMessage) {
        this.m_szMessage = m_szMessage;
    }
    public String getMessage() {
        return m_szMessage;
    }
    public void setSender(String m_szSender) {
        this.m_szSender = m_szSender;
    }
    public String getSender() {
        return m_szSender;
    }

    public void addAttachment(String szAttachment) {
        this.m_attachments.add(szAttachment);
    }
}