/*

  *   SONEWS News Server

  *   see AUTHORS for the list of contributors

  *

  *   This program is free software: you can redistribute it and/or modify

  *   it under the terms of the GNU General Public License as published by

  *   the Free Software Foundation, either version 3 of the License, or

  *   (at your option) any later version.

  *

  *   This program is distributed in the hope that it will be useful,

  *   but WITHOUT ANY WARRANTY; without even the implied warranty of

  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  *   GNU General Public License for more details.

  *

  *   You should have received a copy of the GNU General Public License

  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.

  */

 package org.sonews.daemon.storage;

 import org.sonews.daemon.Config;

 import java.io.BufferedReader;

 import java.io.ByteArrayInputStream;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.nio.charset.Charset;

 import java.sql.SQLException;

 import java.util.UUID;

 import java.util.ArrayList;

 import java.util.Enumeration;

 import java.util.List;

 import javax.mail.Header;

 import javax.mail.Message;

 import javax.mail.MessagingException;

 import javax.mail.Multipart;

 import javax.mail.internet.InternetHeaders;

 import javax.mail.internet.MimeUtility;

 import org.sonews.util.Log;

 /**

  * Represents a newsgroup article.

  * @author Christian Lins

  * @author Denis Schwerdel

  * @since n3tpd/0.1

  */

 public class Article extends ArticleHead

 {

   /**

    * Loads the Article identified by the given ID from the Database.

    * @param messageID

    * @return null if Article is not found or if an error occurred.

    */

   public static Article getByMessageID(final String messageID)

   {

     try

     {

       return Database.getInstance().getArticle(messageID);

     }

     catch(SQLException ex)

     {

       ex.printStackTrace();

       return null;

     }

   }

   public static Article getByArticleNumber(long articleIndex, Group group)

     throws SQLException

   {

     return Database.getInstance().getArticle(articleIndex, group.getID()); 

   }

   private String              body       = "";

   private String              headerSrc  = null;

   /**

    * Default constructor.

    */

   public Article()

   {

   }

   /**

    * Creates a new Article object using the date from the given

    * raw data.

    * This construction has only package visibility.

    */

   Article(String headers, String body)

   {

     try

     {

       this.body  = body;

       // Parse the header

       this.headers = new InternetHeaders(

         new ByteArrayInputStream(headers.getBytes()));

       this.headerSrc = headers;

     }

     catch(MessagingException ex)

     {

       ex.printStackTrace();

     }

   }

   /**

    * Creates an Article instance using the data from the javax.mail.Message

    * object.

    * @see javax.mail.Message

    * @param msg

    * @throws IOException

    * @throws MessagingException

    */

   public Article(final Message msg)

     throws IOException, MessagingException

   {

     this.headers = new InternetHeaders();

     for(Enumeration e = msg.getAllHeaders() ; e.hasMoreElements();) 

     {

       final Header header = (Header)e.nextElement();

       this.headers.addHeader(header.getName(), header.getValue());

     }

     // The "content" of the message can be a String if it's a simple text/plain

     // message, a Multipart object or an InputStream if the content is unknown.

     final Object content = msg.getContent();

     if(content instanceof String)

     {

       this.body = (String)content;

     }

     else if(content instanceof Multipart) // probably subclass MimeMultipart

     {

       // We're are not interested in the different parts of the MultipartMessage,

       // so we simply read in all data which *can* be huge.

       InputStream in = msg.getInputStream();

       this.body = readContent(in);

     }

     else if(content instanceof InputStream)

     {

       // The message format is unknown to the Message class, but we can

       // simply read in the whole message data.

       this.body = readContent((InputStream)content);

     }

     else

     {

       // Unknown content is probably a malformed mail we should skip.

       // On the other hand we produce an inconsistent mail mirror, but no

       // mail system must transport invalid content.

       Log.msg("Skipping message due to unknown content. Throwing exception...", true);

       throw new MessagingException("Unknown content: " + content);

     }

     // Validate headers

     validateHeaders();

   }

   /**

    * Reads lines from the given InputString into a String object.

    * TODO: Move this generalized method to org.sonews.util.io.Resource.

    * @param in

    * @return

    * @throws IOException

    */

   private String readContent(InputStream in)

     throws IOException

   {

     StringBuilder buf = new StringBuilder();

     BufferedReader rin = new BufferedReader(new InputStreamReader(in));

     String line =  rin.readLine();

     while(line != null)

     {

       buf.append('\n');

       buf.append(line);

       line = rin.readLine();

     }

     return buf.toString();

   }

   /**

    * Removes the header identified by the given key.

    * @param headerKey

    */

   public void removeHeader(final String headerKey)

   {

     this.headers.removeHeader(headerKey);

     this.headerSrc = null;

   }

   /**

    * Generates a message id for this article and sets it into

    * the header object. You have to update the Database manually to make this

    * change persistent.

    * Note: a Message-ID should never be changed and only generated once.

    */

   private String generateMessageID()

   {

     String msgID = "<" + UUID.randomUUID() + "@"

         + Config.getInstance().get(Config.HOSTNAME, "localhost") + ">";

     this.headers.setHeader(Headers.MESSAGE_ID, msgID);

     return msgID;

   }

   /**

    * Returns the body string.

    */

   public String getBody()

   {

     return body;

   }

   /**

    * @return Charset of the body text

    */

   public Charset getBodyCharset()

   {

     // We espect something like 

     // Content-Type: text/plain; charset=ISO-8859-15

     String contentType = getHeader(Headers.CONTENT_TYPE)[0];

     int idxCharsetStart = contentType.indexOf("charset=") + "charset=".length();

     int idxCharsetEnd   = contentType.indexOf(";", idxCharsetStart);

     String charsetName = "UTF-8";

     if(idxCharsetStart >= 0 && idxCharsetStart < contentType.length())

     {

       if(idxCharsetEnd < 0)

       {

         charsetName = contentType.substring(idxCharsetStart);

       }

       else

       {

         charsetName = contentType.substring(idxCharsetStart, idxCharsetEnd);

       }

     }

     // Sometimes there are '"' around the name

     if(charsetName.length() > 2 &&

       charsetName.charAt(0) == '"' && charsetName.endsWith("\""))

     {

       charsetName = charsetName.substring(1, charsetName.length() - 2);

     }

     // Create charset

     Charset charset = Charset.forName("UTF-8"); // This MUST be supported by JVM

     try

     {

       charset = Charset.forName(charsetName);

     }

     catch(Exception ex)

     {

       Log.msg(ex.getMessage(), false);

       Log.msg("Article.getBodyCharset(): Unknown charset: " + charsetName, false);

     }

     return charset;

   }

   /**

    * @return Numerical IDs of the newsgroups this Article belongs to.

    */

   List<Group> getGroups()

   {

     String[]         groupnames = getHeader(Headers.NEWSGROUPS)[0].split(",");

     ArrayList<Group> groups     = new ArrayList<Group>();

     try

     {

       for(String newsgroup : groupnames)

       {

         newsgroup = newsgroup.trim();

         Group group = Database.getInstance().getGroup(newsgroup);

         if(group != null &&         // If the server does not provide the group, ignore it

           !groups.contains(group))  // Yes, there may be duplicates

         {

           groups.add(group);

         }

       }

     }

     catch (SQLException ex)

     {

       ex.printStackTrace();

       return null;

     }

     return groups;

   }

   public void setBody(String body)

   {

     this.body = body;

   }

   /**

    * 

    * @param groupname Name(s) of newsgroups

    */

   public void setGroup(String groupname)

   {

     this.headers.setHeader(Headers.NEWSGROUPS, groupname);

   }

   public String getMessageID()

   {

     String[] msgID = getHeader(Headers.MESSAGE_ID);

     return msgID[0];

   }

   public Enumeration getAllHeaders()

   {

     return this.headers.getAllHeaders();

   }

   /**

    * @return Header source code of this Article.

    */

   public String getHeaderSource()

   {

     if(this.headerSrc != null)

     {

       return this.headerSrc;

     }

     StringBuffer buf = new StringBuffer();

     for(Enumeration en = this.headers.getAllHeaders(); en.hasMoreElements();)

     {

       Header entry = (Header)en.nextElement();

       buf.append(entry.getName());

       buf.append(": ");

       buf.append(

         MimeUtility.fold(entry.getName().length() + 2, entry.getValue()));

       if(en.hasMoreElements())

       {

         buf.append("\r\n");

       }

     }

     this.headerSrc = buf.toString();

     return this.headerSrc;

   }

   public long getIndexInGroup(Group group)

     throws SQLException

   {

     return Database.getInstance().getArticleIndex(this, group);

   }

   /**

    * Sets the headers of this Article. If headers contain no

    * Message-Id a new one is created.

    * @param headers

    */

   public void setHeaders(InternetHeaders headers)

   {

     this.headers = headers;

     validateHeaders();

   }

   /**

    * @return String containing the Message-ID.

    */

   @Override

   public String toString()

   {

     return getMessageID();

   }

   /**

    * Checks some headers for their validity and generates an

    * appropriate Path-header for this host if not yet existing.

    * This method is called by some Article constructors and the

    * method setHeaders().

    * @return true if something on the headers was changed.

    */

   private void validateHeaders()

   {

     // Check for valid Path-header

     final String path = getHeader(Headers.PATH)[0];

     final String host = Config.getInstance().get(Config.HOSTNAME, "localhost");

     if(!path.startsWith(host))

     {

       StringBuffer pathBuf = new StringBuffer();

       pathBuf.append(host);

       pathBuf.append('!');

       pathBuf.append(path);

       this.headers.setHeader(Headers.PATH, pathBuf.toString());

     }

     // Generate a messageID if no one is existing

     if(getMessageID().equals(""))

     {

       generateMessageID();

     }

   }

 }