package org.molwind.chemical.view;
   
   /*
    * This file is part of Molwind.
    *
    * Molwind 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.
   *
   * Molwind 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 Molwind. If not, see <http://www.gnu.org/licenses/>.
   */
  
  import java.awt.Color;
  import java.awt.Graphics;
  import java.awt.image.BufferedImage;
  import java.io.File;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.Iterator;
  
  import javax.imageio.ImageIO;
  
  import org.molwind.chemical.model.ChemicalEntity;
  import org.molwind.io.ImageFileCache;
  import org.molwind.model.LayeredPosition;
  import org.molwind.view.AbstractTile;
  
  /**
   * ChemicalTile contains chemical entities and allows to visualize them.
   *
   * @author <a href="mailto:oliver.karch@molwind.org">Oliver Karch</a>
   * @version 1.0
   */
  public class ChemicalTile extends AbstractTile {
  
      private String worldName;
      private File tempDir;
  
      /**
       * Creates a new tile containing chemical entities.
       *
       * @param position
       *      the position of the tile
       */
      public ChemicalTile(final LayeredPosition position) {
          super(position);
          tempDir = null;
      }
  
      /**
       * Get the WorldName value.
       *
       * @return
       *      the WorldName value
       */
      public String getWorldName() {
          return worldName;
      }
  
      /**
       * Set the WorldName value.
       *
       * @param newWorldName
       *      the new WorldName value
       */
      public void setWorldName(final String newWorldName) {
          this.worldName = newWorldName;
      }
  
      /**
       * Get the TempDir value.
       *
       * @return
       *      the TempDir value
       * @throws java.io.IOException
       *      is thrown upon i/o error
       */
      public File getTempDir()
      throws IOException {
          if (tempDir != null) {
              return tempDir;
          }
          File file = File.createTempFile("xxx", null);
          File td = file.getParentFile();
          String worldName = getWorldName();
  
          if (worldName == null) {
              worldName = "world" + System.currentTimeMillis();
          }
  
          File tmpDir = null;
  
         if (td == null) {
             tmpDir = new File(worldName);
         } else {
             tmpDir = new File(td, worldName);
         }
 
         if (!tmpDir.exists() && !tmpDir.mkdirs()) {
             throw new IOException("Cannot create directory " + tmpDir);
         }
 
         setTempDir(tmpDir);
         return tmpDir;
     }
 
     /**
      * Set the TempDir value.
      *
      * @param newTempDir
      *      the new TempDir value
      */
     public void setTempDir(final File newTempDir) {
         this.tempDir = newTempDir;
     }
 
 
     private File getImageFile()
     throws IOException {
         File tmpDir = getTempDir();
         return new File(tmpDir, toFileName());
     }
 
     private String toFileName() {
         StringBuilder builder = new StringBuilder();
 
         builder.append(getPosition());
         builder.append(".");
         builder.append(getImageType());
 
         return builder.toString();
     }
 
     private BufferedImage getImageFromFile()
     throws IOException {
         File tmpImageFile = getImageFile();
         if (!tmpImageFile.exists()) {
             return null;
         }
         return ImageIO.read(tmpImageFile);
     }
 
     private void updateCache(final BufferedImage image)
     throws IOException {
         ImageFileCache imageCache = ImageFileCache.getInstance();
         File imageFile = getImageFile();
         imageCache.update(imageFile, imageCache);
     }
 
     private BufferedImage createImage(final int width, final int height) {
         BufferedImage image = new BufferedImage(width, height,
                 BufferedImage.TYPE_INT_RGB);
         Graphics graphic = image.getGraphics();
         graphic.setColor(Color.white);
         graphic.fillRect(0, 0, width, height);
         return image;
     }
 
     private BufferedImage composeImage(final Iterator it) {
         BufferedImage image = createImage(420, 420);
 
         LayeredPosition position = getPosition();
 
         double levelFactor = 30 / Math.pow(2, position.getLayer());
         double xTile = levelFactor * position.getX();
         double yTile = levelFactor * position.getY();
 
         Graphics graphic = image.getGraphics();
 
         while (it.hasNext()) {
             ChemicalEntity chemicalEntity = (ChemicalEntity) it.next();
 
             BufferedImage moleculeImage = chemicalEntity.getDrawing();
             int height = moleculeImage.getHeight(null);
 
             double xTemp = 420 / levelFactor * (chemicalEntity.getX() - xTile);
             double yTemp = 420 / levelFactor * (chemicalEntity.getY() - yTile);
 
             graphic.drawImage(moleculeImage,
                     (int) xTemp, 420 - (int) yTemp - height, null);
         }
         return image;
     }
 
     /**
      * Writes the tile's image to the given output stream.
      *
      * @param output
      *      the output stream
      * @throws java.io.IOException
      *      is thrown upon i/o error
      */
     public void writeTo(final OutputStream output)
     throws IOException {
 
         BufferedImage image = getImageFromCache();
         if (image == null) {
             image = getImageFromFile();
             if (image == null) {
                 if (getEntityCount() <= 0) {
                     image = getEmptyImage();
                 } else {
                     image = composeImage(getEntityIterator());
                 }
                 updateCache(image);
             }
         }
         if (!ImageIO.write(image, getImageType(), output)) {
             throw new IOException("Cannot write image");
         }
     }
 
     private BufferedImage getImageFromCache()
     throws IOException {
         ImageFileCache imageCache = ImageFileCache.getInstance();
         return imageCache.getImage(getImageFile());
     }
 
 }