/*
    * Copyright 2007-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.maven.exceptions.sdoc;
  
  import java.io.File;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.MissingResourceException;
  import java.util.ResourceBundle;
  
  import javax.xml.stream.XMLStreamException;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.w3c.dom.DOMException;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.Text;
  
  import com.thoughtworks.qdox.model.JavaAnnotatedElement;
  import com.thoughtworks.qdox.model.JavaClass;
  import com.thoughtworks.qdox.model.JavaField;
  
  import de.smartics.exceptions.core.Code;
  import de.smartics.exceptions.i18n.message.MessageType;
  import de.smartics.exceptions.report.data.ExceptionCodeReportItem;
  import de.smartics.exceptions.report.data.ProjectConfiguration;
  import de.smartics.exceptions.report.message.PlaceHolderDesc;
  import de.smartics.exceptions.report.message.PlaceHolderInfo;
  import de.smartics.exceptions.report.renderer.JavadocRenderer;
  import de.smartics.maven.exceptions.util.TextCoder;
  import de.smartics.messages.core.BundleMapper;
  import de.smartics.xml.DomCopyReader;
  
  /**
   * Creates the content for a projectdoc code doctype instance.
   */
  public class SdocCodeBuilder
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    /**
     * Reference to the logger for this class.
     */
    private static final Log LOG = LogFactory.getLog(SdocCodeBuilder.class);
  
    /**
     * The URI of the XML schema instance.
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    private static final String XML_SCHEMA_INSTANCE =
        "http://www.w3.org/2001/XMLSchema-instance";
  
    /**
     * The URI of the code doctype.
     * <p>
     * The value of this constant is {@value}.
     * </p>
     */
    private static final String CODE_URI =
        "http://www.smartics.de/project/process/implementation/appcode";
  
    // --- members --------------------------------------------------------------
  
    /**
     * The renderer to use for processing Javadoc comments.
     */
    private final JavadocRenderer renderer;
  
    /**
     * Helper to encode and decode texts according to the encodings requested by
     * the project configuration.
     */
    private final TextCoder coder;
  
    /**
     * The mapping of a code instance to a bundle.
     */
    private final BundleMapper mapper;
  
   /**
    * The resource bundle with labels to render.
    */
   private final ResourceBundle bundle;
 
   /**
    * The empty document to write to.
    */
   private final Document document;
 
   /**
    * The code representation of the runtime environement.
    */
   private final String codeRepresentation;
 
   /**
    * Static information about the code to write to the document.
    */
   private final ExceptionCodeReportItem codeContainer;
 
   // ****************************** Initializer *******************************
 
   // ****************************** Constructors ******************************
 
   /**
    * Default constructor.
    *
    * @param renderer the renderer to use for processing Javadoc comments.
    * @param config the project configuration.
    * @param document the empty document to write to.
    * @param codeRepresentation the code representation of the runtime
    *          environment.
    * @param codeContainer the value for codeContainer.
    */
   SdocCodeBuilder(final JavadocRenderer renderer,
       final ProjectConfiguration<File> config, final Document document,
       final String codeRepresentation,
       final ExceptionCodeReportItem codeContainer)
   {
     this.coder = new TextCoder(config);
     this.renderer = renderer;
     this.mapper = config.getBundleMapper();
     this.bundle = config.getBundle();
     this.document = document;
     this.codeRepresentation = codeRepresentation;
     this.codeContainer = codeContainer;
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * Writes the content to the document.
    */
   public Document writeDocumentContent()
   {
     final JavaField fieldDoc = codeContainer.getJavadoc();
     final JavaClass classDoc = codeContainer.getTypeJavadoc();
 
     final TagInfo tagInfo = new TagInfo(classDoc, fieldDoc);
 
     final Element docRoot = createDocRoot();
     createContentElement("id", codeRepresentation, docRoot);
     createContentElement("name", tagInfo.getName(), docRoot); // NOPMD
     createContentElement("type", tagInfo.getCodeType(), docRoot);
 
     final String componentId = codeContainer.getCode().getComponentId();
     createContentElement("component", componentId, docRoot);
 
     createImplementationElement(classDoc.getFullyQualifiedName(),
         fieldDoc.getName(), docRoot);
     createContentElement("category", tagInfo.getCategory(), docRoot);
     createContentElement("subcategory", tagInfo.getSubcategory(), docRoot);
     createContentElement("sort-key", tagInfo.getSortKey(), docRoot);
     createContentElement("parents", "parent", tagInfo.getParents(), docRoot);
     createContentElement("tags", "tag", tagInfo.getTags(), docRoot);
     renderShortDescription(tagInfo, fieldDoc, docRoot);
     renderJavadocContent("package-description", docRoot,
         createJavadoc(classDoc));
     renderJavadocContent("description", docRoot, createJavadoc(fieldDoc)); // NOPMD
     createContentElement("notes", tagInfo.getNotes(), docRoot);
 
     renderMessages(docRoot);
 
     return document;
   }
 
   private void renderShortDescription(final TagInfo tagInfo,
       final JavaField fieldDoc, final Element docRoot) throws DOMException
   {
     String text = tagInfo.getShortDescription();
     if (StringUtils.isBlank(text))
     {
       final String comment = fieldDoc.getComment();
       if (comment != null)
       {
         final int index = comment.indexOf('.'); // FIXME: Too crude, dot my be
                                                 // escaped.
         if (index != -1 && index < comment.length() - 2)
         {
           final String firstSentence = comment.substring(0, index + 1);
           text = firstSentence;
         }
         else
         {
           text = comment;
         }
       }
     }
 
     if (StringUtils.isNotBlank(text))
     {
       renderJavadocContent("short-description", docRoot, text);
     }
   }
 
   private void createImplementationElement(final String implementingClassName,
       final String implementingFieldName, final Element docRoot)
   {
     final Element implementation = document.createElement("implementation");
     docRoot.appendChild(implementation);
     createContentElement("class", implementingClassName, implementation);
     createContentElement("field", implementingFieldName, implementation);
   }
 
   private void createContentElement(final String groupGi, final String gi,
       final List<String> contents, final Element docRoot)
   {
     if (!contents.isEmpty())
     {
       final Element group = document.createElement(groupGi);
       docRoot.appendChild(group);
       for (final String content : contents)
       {
         createContentElement(gi, content, group);
       }
     }
   }
 
   private void renderJavadocContent(final String gi,
       final Element parentElement, final String content) throws DOMException
   {
     if (StringUtils.isNotBlank(content))
     {
       final Element element = document.createElement(gi);
       parentElement.appendChild(element);
       final DomCopyReader copy = new DomCopyReader(document, element);
       try
       {
         copy.copy(content);
       }
       catch (final XMLStreamException e)
       {
         if (LOG.isWarnEnabled())
         {
           LOG.warn("Cannot parse Javdoc content as XML. Using it verbatim: "
                    + content);
         }
         createContentElement("description", content, parentElement);
       }
     }
   }
 
   private Element createContentElement(final String gi, final String content,
       final Element parent)
   {
     if (content != null)
     {
       final String encoded = coder.run(content);
       return createPlainContentElement(gi, encoded, parent);
     }
     return null;
   }
 
   private Element createPlainContentElement(final String gi,
       final String content, final Element parent)
   {
     if (content != null)
     {
       final Element element = document.createElement(gi);
       final Text text = document.createTextNode(content);
       element.appendChild(text);
       parent.appendChild(element);
       return element;
     }
     return null;
   }
 
   private String createJavadoc(final JavaAnnotatedElement doc)
   {
     final String javadoc = this.renderer.render(doc);
     return StringUtils.isNotBlank(javadoc) ? coder.run(javadoc) : "&#160;";
   }
 
   private Element createDocRoot() throws DOMException
   {
     final Element docRoot = document.createElement("appcode");
     docRoot.setAttribute("xmlns:xsi", XML_SCHEMA_INSTANCE);
     docRoot.setAttribute("xmlns", CODE_URI);
     docRoot.setAttribute("xsi:schemaLocation", CODE_URI + ' ' + CODE_URI);
     document.appendChild(docRoot);
     return docRoot;
   }
 
   private void renderMessages(final Element parent)
   {
     if (mapper != null)
     {
       final Code code = codeContainer.getCode();
       final Class<?> codeClass = code.getClass();
       try
       {
         final ResourceBundle messageBundle =
             mapper.getBundle(codeClass, this.bundle.getLocale());
         if (messageBundle != null)
         {
           addMessages(parent, codeContainer, messageBundle);
         }
       }
       catch (final MissingResourceException e)
       {
         if (LOG.isWarnEnabled())
         {
           LOG.warn("Cannot load resource bundle for code class '" + codeClass
                    + "'.", e);
         }
       }
     }
   }
 
   private void addMessages(final Element parent,
       final ExceptionCodeReportItem codeContainer, final ResourceBundle bundle)
     throws DOMException
   {
     final Element messages = document.createElement("messages");
     addMessages(codeContainer, bundle, messages);
     if (messages.hasChildNodes())
     {
       parent.appendChild(messages);
     }
   }
 
   private void addMessages(final ExceptionCodeReportItem codeContainer,
       final ResourceBundle bundle, final Element messages) throws DOMException
   {
     for (MessageType type : MessageType.values())
     {
       final String keyPrefix = codeContainer.getCode().getCode();
       final String key = type.createKey(keyPrefix);
       addText(codeContainer, bundle, messages, type, key);
     }
   }
 
   private void addText(final ExceptionCodeReportItem codeContainer,
       final ResourceBundle bundle, final Element messages,
       final MessageType messageType, final String key) throws DOMException
   {
     try
     {
       final String text = bundle.getString(key);
       if (StringUtils.isNotBlank(text))
       {
         final String encoded = text; // coder.run(text);
         final String typeId = getTypeId(messageType);
         final Element message = document.createElement("message");
         createContentElement("name", renderTypeId(typeId), message);
         final Element textElement =
             createPlainContentElement("text", encoded, message);
         final Map<String, String> placeHolderMap =
             addPlaceHolders(messageType, codeContainer, message, bundle,
                 encoded);
         if (!placeHolderMap.isEmpty())
         {
           replaceText(placeHolderMap, textElement);
         }
         messages.appendChild(message);
       }
     }
     catch (final MissingResourceException e)
     {
       // ok, skip
     }
   }
 
   private String renderTypeId(final String typeId)
   {
     try
     {
       final String message = bundle.getString("label." + typeId);
       return message;
     }
     catch (final Exception e)
     {
       if (LOG.isDebugEnabled())
       {
         LOG.debug("No translation for '" + typeId
                   + "' found in resource bundle.");
       }
       return typeId;
     }
   }
 
   private void replaceText(final Map<String, String> placeHolderMap,
       final Element textElement)
   {
     final Text textNode = (Text) textElement.getFirstChild();
     String text = textNode.getTextContent();
     for (Map.Entry<String, String> entry : placeHolderMap.entrySet())
     {
       final String key = entry.getKey();
       if (isNumeric(key))
       {
         final String value = entry.getValue();
         if(text.contains(key))
         {
           text = StringUtils.replace(text, key, '{' + value + '}');
         }
         else
         {
           final String altKey = StringUtils.chop(key) + ',';
           text = StringUtils.replace(text, altKey, '{' + value + ',');
         }
       }
     }
     text = StringUtils.replace(text, "''", "'");
     textNode.setTextContent(text);
   }
 
   private boolean isNumeric(final String key)
   {
     final int length = key.length();
     boolean foundDigit = false;
     for (int i = 1; i < length; i++)
     {
       final char c = key.charAt(i);
       if (!Character.isDigit(c))
       {
         break;
       }
       foundDigit = Character.isDigit(c);
     }
 
     return foundDigit;
   }
 
   private Map<String, String> addPlaceHolders(final MessageType messageType,
       final ExceptionCodeReportItem codeContainer, final Element parent,
       final ResourceBundle bundle, final String messageText)
     throws DOMException
   {
     final Element placeholders = document.createElement("placeholders");
     final Map<String, String> placeHolderMap =
         addPlaceholder(messageType, codeContainer.getPlaceHolderInfo(), bundle,
             placeholders, messageText);
     if (placeholders.hasChildNodes())
     {
       parent.appendChild(placeholders);
     }
     return placeHolderMap;
   }
 
   private Map<String, String> addPlaceholder(final MessageType messageType,
       final PlaceHolderInfo placeHolderInfo, final ResourceBundle bundle,
       final Element placeholders, final String messageText)
   {
     final Map<String, String> placeHolderMap = new HashMap<String, String>();
 
     for (PlaceHolderDesc desc : placeHolderInfo
         .getPlaceHolderDescs(messageType))
     {
       final Element placeholder = document.createElement("placeholder");
       final String index = desc.getPlaceHolderIndex();
       final String placeHolderString = '{' + index + '}';
       if (messageText.contains(placeHolderString)
           || messageText.contains('{' + index + ','))
       {
         final String path = desc.getOgnlPath();
         final String name =
             desc.getParamName()
                 + (path != null ? ':' + desc.getOgnlPath() : "");
         final String description = desc.getDescription();
 
         if (StringUtils.isNumeric(index))
         {
           createContentElement("name", name, placeholder);
         }
         else
         {
           createContentElement("name", index, placeholder);
         }
         createContentElement("description", description, placeholder);
         placeholders.appendChild(placeholder);
 
         placeHolderMap.put(placeHolderString, name);
       }
     }
 
     return placeHolderMap;
   }
 
   private String getTypeId(final MessageType type)
   {
     final String id = type.getMessageKeySuffix();
     if (StringUtils.EMPTY.equals(id))
     {
       return "summary";
     }
     else
     {
       return id.substring(1);
     }
   }
 
   // --- object basics --------------------------------------------------------
 }