/*
 * Copyright (c) 1997, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package com.sun.mail.mbox;

import java.io.*;
import java.util.StringTokenizer;
import java.util.Date;
import java.text.SimpleDateFormat;
import javax.activation.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.mail.event.MessageChangedEvent;
import com.sun.mail.util.LineInputStream;

/**
 * This class represents an RFC822 style email message that resides in a file.
 *
 * @author Bill Shannon
 */

public class MboxMessage extends MimeMessage {

    boolean writable = false;
    // original msg flags, used by MboxFolder to detect modification
    Flags origFlags;
    /*
     * A UNIX From line looks like:
     * From address Day Mon DD HH:MM:SS YYYY
     */
    String unix_from;
    InternetAddress unix_from_user;
    Date rcvDate;
    int lineCount = -1;
    private static OutputStream nullOutputStream = new OutputStream() {
	public void write(int b) { }
	public void write(byte[] b, int off, int len) { }
    };

    /**
     * Construct an MboxMessage from the InputStream.
     */
    public MboxMessage(Session session, InputStream is)
				throws MessagingException, IOException {
	super(session);
	BufferedInputStream bis;
	if (is instanceof BufferedInputStream)
	    bis = (BufferedInputStream)is;
	else
	    bis = new BufferedInputStream(is);
	LineInputStream dis = new LineInputStream(bis);
	bis.mark(1024);
	String line = dis.readLine();
	if (line != null && line.startsWith("From "))
	    this.unix_from = line;
	else
	    bis.reset();
	parse(bis);
	saved = true;
    }

    /**
     * Construct an MboxMessage using the given InternetHeaders object
     * and content from an InputStream.
     */
    public MboxMessage(MboxFolder folder, InternetHeaders hdrs, InputStream is,
				int msgno, String unix_from, boolean writable)
				throws MessagingException {
	super(folder, hdrs, null, msgno);
	setFlagsFromHeaders();
	origFlags = getFlags();
	this.unix_from = unix_from;
	this.writable = writable;
	this.contentStream = is;
    }

    /**
     * Returns the "From" attribute. The "From" attribute contains
     * the identity of the person(s) who wished this message to 
     * be sent. <p>
     * 
     * If our superclass doesn't have a value, we return the address
     * from the UNIX From line.
     *
     * @return          array of Address objects
     * @exception       MessagingException
     */
    public Address[] getFrom() throws MessagingException {
	Address[] ret = super.getFrom();
	if (ret == null) {
	    InternetAddress ia = getUnixFrom();
	    if (ia != null)
		ret = new InternetAddress[] { ia };
	}
	return ret;
    }

    /**
     * Returns the address from the UNIX "From" line.
     *
     * @return          UNIX From address
     * @exception       MessagingException
     */
    public synchronized InternetAddress getUnixFrom()
				throws MessagingException {
	if (unix_from_user == null && unix_from != null) {
	    int i;
	    // find the space after the address, before the date
	    i = unix_from.indexOf(' ', 5);
	    if (i > 5) {
		try {
		    unix_from_user =
			new InternetAddress(unix_from.substring(5, i));
		} catch (AddressException e) {
		    // ignore it
		}
	    }
	}
	return unix_from_user != null ?
		(InternetAddress)unix_from_user.clone() : null;
    }

    private String getUnixFromLine() {
	if (unix_from != null)
	    return unix_from;
	String from = "unknown";
	try {
	    Address[] froma = getFrom();
	    if (froma != null && froma.length > 0 &&
		    froma[0] instanceof InternetAddress)
		from = ((InternetAddress)froma[0]).getAddress();
	} catch (MessagingException ex) { }
	Date d = null;
	try {
	    d = getSentDate();
	} catch (MessagingException ex) {
	    // ignore
	}
	if (d == null)
	    d = new Date();
	// From shannon Mon Jun 10 12:06:52 2002
	SimpleDateFormat fmt = new SimpleDateFormat("EEE LLL dd HH:mm:ss yyyy");
	return "From " + from + " " + fmt.format(d);
    }

    /**
     * Get the date this message was received, from the UNIX From line.
     *
     * @return          the date this message was received
     * @exception       MessagingException
     */
    @SuppressWarnings("deprecation")	// for Date constructor
    public Date getReceivedDate() throws MessagingException {
	if (rcvDate == null && unix_from != null) {
	    int i;
	    // find the space after the address, before the date
	    i = unix_from.indexOf(' ', 5);
	    if (i > 5) {
		try {
		    rcvDate = new Date(unix_from.substring(i));
		} catch (IllegalArgumentException iae) {
		    // ignore it
		}
	    }
	}
	return rcvDate == null ? null : new Date(rcvDate.getTime());
    }

    /**
     * Return the number of lines for the content of this message.
     * Return -1 if this number cannot be determined. <p>
     *
     * Note that this number may not be an exact measure of the 
     * content length and may or may not account for any transfer 
     * encoding of the content. <p>
     *
     * This implementation returns -1.
     *
     * @return          number of lines in the content.
     * @exception	MessagingException
     */  
    public int getLineCount() throws MessagingException {
	if (lineCount < 0 && isMimeType("text/plain")) {
	    LineCounter lc = null;
	    // writeTo will set the SEEN flag, remember the original state
	    boolean seen = isSet(Flags.Flag.SEEN);
	    try {
		lc = new LineCounter(nullOutputStream);
		getDataHandler().writeTo(lc);
		lineCount = lc.getLineCount();
	    } catch (IOException ex) {
		// ignore it, can't happen
	    } finally {
		try {
		    if (lc != null)
			lc.close();
		} catch (IOException ex) {
		    // can't happen
		}
	    }
	    if (!seen)
		setFlag(Flags.Flag.SEEN, false);
	}
	return lineCount;
     }

    /**
     * Set the specified flags on this message to the specified value.
     *
     * @param flags	the flags to be set
     * @param set	the value to be set
     */
    public void setFlags(Flags newFlags, boolean set)
				throws MessagingException {
	Flags oldFlags = (Flags)flags.clone();
	super.setFlags(newFlags, set);
	if (!flags.equals(oldFlags)) {
	    setHeadersFromFlags(this);
	    if (folder != null)
		((MboxFolder)folder).notifyMessageChangedListeners(
				MessageChangedEvent.FLAGS_CHANGED, this);
	}
    }

    /**
     * Return the content type, mapping from SunV3 types to MIME types
     * as necessary.
     */
    public String getContentType()  throws MessagingException {
	String ct = super.getContentType();
	if (ct.indexOf('/') < 0)
	    ct = SunV3BodyPart.MimeV3Map.toMime(ct);
	return ct;
    }

    /**
     * Produce the raw bytes of the content. This method is used during
     * parsing, to create a DataHandler object for the content. Subclasses
     * that can provide a separate input stream for just the message 
     * content might want to override this method. <p>
     *
     * This implementation just returns a ByteArrayInputStream constructed
     * out of the <code>content</code> byte array.
     *
     * @see #content
     */
    protected InputStream getContentStream() throws MessagingException {
	if (folder != null)
	    ((MboxFolder)folder).checkOpen();
	if (isExpunged())
	    throw new MessageRemovedException("mbox message expunged");
	if (!isSet(Flags.Flag.SEEN))
	    setFlag(Flags.Flag.SEEN, true);
	return super.getContentStream();
    }

    /**                                                            
     * Return a DataHandler for this Message's content.
     * If this is a SunV3 multipart message, handle it specially.
     *
     * @exception	MessagingException
     */
    public synchronized DataHandler getDataHandler() 
		throws MessagingException {
	if (dh == null) {
	    // XXX - Following is a kludge to avoid having to register
	    // the "multipart/x-sun-attachment" data type with the JAF.
	    String ct = getContentType();
	    if (ct.equalsIgnoreCase("multipart/x-sun-attachment"))
		dh = new DataHandler(
		    new SunV3Multipart(new MimePartDataSource(this)), ct);
	    else
		return super.getDataHandler();	// will set "dh"
	}
	return dh;
    }

    // here only to allow package private access from MboxFolder
    protected void setMessageNumber(int msgno) {
	super.setMessageNumber(msgno);
    }

    // here to synchronize access to expunged field
    public synchronized boolean isExpunged() {
	return super.isExpunged();
    }

    // here to synchronize and to allow access from MboxFolder
    protected synchronized void setExpunged(boolean expunged) {
	super.setExpunged(expunged);
    }

    // XXX - We assume that only body parts that are part of a SunV3
    // multipart will use the SunV3 headers (X-Sun-Content-Length,
    // X-Sun-Content-Lines, X-Sun-Data-Type, X-Sun-Encoding-Info,
    // X-Sun-Data-Description, X-Sun-Data-Name) so we don't handle
    // them here.

    /**
     * Set the flags for this message based on the Status,
     * X-Status, and X-Dt-Delete-Time headers.
     *
     * SIMS 2.0:
     * "X-Status: DFAT", deleted, flagged, answered, draft.
     * Unset flags represented as "$".
     * User flags not supported.
     *
     * University of Washington IMAP server:
     * "X-Status: DFAT", deleted, flagged, answered, draft.
     * Unset flags not present.
     * "X-Keywords: userflag1 userflag2"
     */
    private synchronized void setFlagsFromHeaders() {
	flags = new Flags(Flags.Flag.RECENT);
	try {
	    String s = getHeader("Status", null);
	    if (s != null) {
		if (s.indexOf('R') >= 0)
		    flags.add(Flags.Flag.SEEN);
		if (s.indexOf('O') >= 0)
		    flags.remove(Flags.Flag.RECENT);
	    }
	    s = getHeader("X-Dt-Delete-Time", null);	// set by dtmail
	    if (s != null)
		flags.add(Flags.Flag.DELETED);
	    s = getHeader("X-Status", null);		// set by IMAP server
	    if (s != null) {
		if (s.indexOf('D') >= 0)
		    flags.add(Flags.Flag.DELETED);
		if (s.indexOf('F') >= 0)
		    flags.add(Flags.Flag.FLAGGED);
		if (s.indexOf('A') >= 0)
		    flags.add(Flags.Flag.ANSWERED);
		if (s.indexOf('T') >= 0)
		    flags.add(Flags.Flag.DRAFT);
	    }
	    s = getHeader("X-Keywords", null);		// set by IMAP server
	    if (s != null) {
		StringTokenizer st = new StringTokenizer(s);
		while (st.hasMoreTokens())
		    flags.add(st.nextToken());
	    }
	} catch (MessagingException e) {
	    // ignore it
	}
    }

    /**
     * Set the various header fields that represent the message flags.
     */
    static void setHeadersFromFlags(MimeMessage msg) {
	try {
	    Flags flags = msg.getFlags();
	    StringBuilder status = new StringBuilder();
	    if (flags.contains(Flags.Flag.SEEN))
		status.append('R');
	    if (!flags.contains(Flags.Flag.RECENT))
		status.append('O');
	    if (status.length() > 0)
		msg.setHeader("Status", status.toString());
	    else
		msg.removeHeader("Status");

	    boolean sims = false;
	    String s = msg.getHeader("X-Status", null);
	    // is it a SIMS 2.0 format X-Status header?
	    sims = s != null && s.length() == 4 && s.indexOf('$') >= 0;
	    status.setLength(0);
	    if (flags.contains(Flags.Flag.DELETED))
		status.append('D');
	    else if (sims)
		status.append('$');
	    if (flags.contains(Flags.Flag.FLAGGED))
		status.append('F');
	    else if (sims)
		status.append('$');
	    if (flags.contains(Flags.Flag.ANSWERED))
		status.append('A');
	    else if (sims)
		status.append('$');
	    if (flags.contains(Flags.Flag.DRAFT))
		status.append('T');
	    else if (sims)
		status.append('$');
	    if (status.length() > 0)
		msg.setHeader("X-Status", status.toString());
	    else
		msg.removeHeader("X-Status");

	    String[] userFlags = flags.getUserFlags();
	    if (userFlags.length > 0) {
		status.setLength(0);
		for (int i = 0; i < userFlags.length; i++)
		    status.append(userFlags[i]).append(' ');
		status.setLength(status.length() - 1);	// smash trailing space
		msg.setHeader("X-Keywords", status.toString());
	    }
	    if (flags.contains(Flags.Flag.DELETED)) {
		s = msg.getHeader("X-Dt-Delete-Time", null);
		if (s == null)
		    // XXX - should be time
		    msg.setHeader("X-Dt-Delete-Time", "1");
	    }
	} catch (MessagingException e) {
	    // ignore it
	}
    }

    protected void updateHeaders() throws MessagingException {
	super.updateHeaders();
	setHeadersFromFlags(this);
    }

    /**
     * Save any changes made to this message.
     */
    public void saveChanges() throws MessagingException {
	if (folder != null)
	    ((MboxFolder)folder).checkOpen();
	if (isExpunged())
	    throw new MessageRemovedException("mbox message expunged");
	if (!writable)
	    throw new MessagingException("Message is read-only");

	super.saveChanges();

	try {
	    /*
	     * Count the size of the body, in order to set the Content-Length
	     * header.  (Should we only do this to update an existing
	     * Content-Length header?)
	     * XXX - We could cache the content bytes here, for use later
	     * in writeTo.
	     */
	    ContentLengthCounter cos = new ContentLengthCounter();
	    OutputStream os = new NewlineOutputStream(cos);
	    super.writeTo(os);
	    os.flush();
	    setHeader("Content-Length", String.valueOf(cos.getSize()));
	    // setContentSize((int)cos.getSize());
	} catch (MessagingException e) {
	    throw e;
	} catch (Exception e) {
	    throw new MessagingException("unexpected exception " + e);
	}
    }

    /**
     * Expose modified flag to MboxFolder.
     */
    boolean isModified() {
	return modified;
    }

    /**
     * Put out a byte stream suitable for saving to a file.
     * XXX - ultimately implement "ignore headers" here?
     */
    public void writeToFile(OutputStream os) throws IOException {
	try {
	    if (getHeader("Content-Length") == null) {
		/*
		 * Count the size of the body, in order to set the
		 * Content-Length header.
		 */
		ContentLengthCounter cos = new ContentLengthCounter();
		OutputStream oos = new NewlineOutputStream(cos);
		super.writeTo(oos, null);
		oos.flush();
		setHeader("Content-Length", String.valueOf(cos.getSize()));
		// setContentSize((int)cos.getSize());
	    }

	    os = new NewlineOutputStream(os, true);
	    PrintStream pos = new PrintStream(os, false, "iso-8859-1");

	    pos.println(getUnixFromLine());
	    super.writeTo(pos, null);
	    pos.flush();
	} catch (MessagingException e) {
	    throw new IOException("unexpected exception " + e);
	}
    }

    public void writeTo(OutputStream os, String[] ignoreList)
				throws IOException, MessagingException {
	// set the SEEN flag now, which will normally be set by
	// getContentStream, so it will show up in our headers
	if (!isSet(Flags.Flag.SEEN))
	    setFlag(Flags.Flag.SEEN, true);
	super.writeTo(os, ignoreList);
    }

    /**
     * Interpose on superclass method to make sure folder is still open
     * and message hasn't been expunged.
     */
    public String[] getHeader(String name)
			throws MessagingException {
	if (folder != null)
	    ((MboxFolder)folder).checkOpen();
	if (isExpunged())
	    throw new MessageRemovedException("mbox message expunged");
	return super.getHeader(name);
    }

    /**
     * Interpose on superclass method to make sure folder is still open
     * and message hasn't been expunged.
     */
    public String getHeader(String name, String delimiter)
				throws MessagingException {
	if (folder != null)
	    ((MboxFolder)folder).checkOpen();
	if (isExpunged())
	    throw new MessageRemovedException("mbox message expunged");
	return super.getHeader(name, delimiter);
    }
}