package org.jimkast.xsl.ext;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.net.URLStreamHandler;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.URLDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.util.ByteArrayDataSource;
import org.cactoos.Proc;
import org.cactoos.func.IoCheckedProc;
import org.eclipse.jetty.util.MultiMap;
import org.eclipse.jetty.util.UrlEncoded;

public final class EmailExtendedURL extends URLStreamHandler {
    private final Session session;

    public EmailExtendedURL() {
        Properties props = new Properties();
        props.setProperty("mail.smtp.host", "localhost");
        props.setProperty("mail.smtp.port", "25");
        this.session = Session.getDefaultInstance(props);
    }

    public EmailExtendedURL(Session session) {
        this.session = session;
    }

    @Override
    protected URLConnection openConnection(URL u) {
        return new Conn(session, u);
    }


    public static final class Conn extends URLConnection {
        private OutputStream out = null;
        private Session session;

        public Conn(Session session, URL url) {
            super(url);
            this.session = session;
        }

        @Override
        public void connect() {
            if (out == null) {
                out = EmailOutputStream.fromUrl(session, getURL());
            }
        }

        @Override
        public OutputStream getOutputStream() {
            return out;
        }
    }


    public static final class EmailOutputStream extends OutputStream {
        private static final List<String> EMPTY = Collections.emptyList();
        private static final List<String> SINGLE_EMPTY = Collections.singletonList("");
        private static final List<String> CONTENT_TYPE = Collections.singletonList("text/plain");

        private final Session session;
        private final MultiMap<String> params;
        private final IoCheckedProc<Message> wire;
        private final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        private boolean flushed = false;

        public EmailOutputStream(Session session, MultiMap<String> params) {
            this(session, params, Transport::send);
        }

        public EmailOutputStream(Session session, MultiMap<String> params, Proc<Message> wire) {
            this(session, params, new IoCheckedProc<>(wire));
        }

        public EmailOutputStream(Session session, MultiMap<String> params, IoCheckedProc<Message> wire) {
            this.session = session;
            this.params = params;
            this.wire = wire;
        }

        @Override
        public void write(int b) {
            baos.write(b);
        }

        @Override
        public void write(byte[] b) throws IOException {
            baos.write(b);
        }

        @Override
        public void write(byte[] b, int off, int len) {
            baos.write(b, off, len);
        }

        @Override
        public void flush() throws IOException {
            if (flushed) {
                return;
            }
            flushed = true;
            try {
                MimeMessage msg = new MimeMessage(session);
                msg.setSubject(params.getOrDefault("subject", SINGLE_EMPTY).get(0));
                msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(params.getOrDefault("to", SINGLE_EMPTY).get(0)));
                msg.setRecipients(Message.RecipientType.CC, InternetAddress.parse(params.getOrDefault("cc", SINGLE_EMPTY).get(0)));
                msg.setRecipients(Message.RecipientType.BCC, InternetAddress.parse(params.getOrDefault("bcc", SINGLE_EMPTY).get(0)));
                msg.setReplyTo(InternetAddress.parse(params.getOrDefault("reply-to", SINGLE_EMPTY).get(0)));
                String from = params.getOrDefault("from", SINGLE_EMPTY).get(0);
                if (!from.isEmpty()) {
                    msg.setFrom(new InternetAddress(from));
                }
                Multipart mp = new MimeMultipart();
                BodyPart main = new MimeBodyPart();
                main.setDataHandler(new DataHandler(new ByteArrayDataSource(new ByteArrayInputStream(baos.toByteArray()), params.getOrDefault("content-type", CONTENT_TYPE).get(0))));
    //            main.setContent(baos.toByteArray(), params.getOrDefault("content-type", CONTENT_TYPE).get(0));
                mp.addBodyPart(main);
                for (String href : params.getOrDefault("attachment", EMPTY)) {
                    BodyPart part = new MimeBodyPart();
                    URL url = new URL(href);
                    part.setDataHandler(new DataHandler(new URLDataSource(url)));
                    part.setFileName(URLDecoder.decode(url.getPath().substring(url.getPath().lastIndexOf('/') + 1), "UTF-8"));
                    mp.addBodyPart(part);
                }
                msg.setContent(mp);
                wire.exec(msg);
            } catch (MessagingException e) {
                throw new IOException(e);
            }
        }

        @Override
        public void close() throws IOException {
            this.flush();
        }


        public static OutputStream fromUrl(Session session, URL url) {
            MultiMap<String> params = new MultiMap<>();
            String q = url.getQuery();
            if (q != null && !q.isEmpty()) {
                UrlEncoded.decodeTo(q, params, StandardCharsets.UTF_8);
            }
            try {
                params.add("to", URLDecoder.decode(url.getPath(), "UTF-8"));
                return new EmailOutputStream(session, params);
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
        }


        public static OutputStream fromUrl(Session session, String url) throws MalformedURLException {
            return fromUrl(session, new URL(url));
        }
    }
}