import com.threed.jpct.*;

import java.util.*;
import java.awt.*;
import java.awt.image.*;

/**
 * a simple area based mip mapper implementation for the software renderer.
 * i.e: mip map level per polygon is decided according to ratio:
 * area of polygon on screen / area of polygon on texture
 *
 * Note: This class shouldn't be used when the hardware renderer is being used (use Config.mipmap instead).
 *
 * @author r a f t (area based algorithm, multi object support)
 * @author EgonOlsen (initial version, back ported to Java 1.1)
 */
public class MipMapper {
   /** the number of mipmap levels */
   public static final int LEVELS=6; // enough for mip mapping a 256x256 texture to 8x8

   /** the minimum mipmap size (lower isn't possible because of a jPCT limitation, higher is) */
   public static final int MIN_SIZE=8;

   /** original texture will be used dwon to this ratio (polygon area / texture area) */
   public static final float FIRST_LEVEL=1/2f;

   /** debug switch for showing colored mip maps */
   public static boolean colorMipmaps=false;

   private TextureManager tm=TextureManager.getInstance();

   private int[] visListData=new int[2];

   private ObjectData[] changedObjects=new ObjectData[8];
   private BitSet processedTextures=new BitSet(256);

   private Hashtable mipMappedObjs=new Hashtable();
   private Hashtable textureIds=new Hashtable();
   private Vector createdTextures=new Vector();

   private int lastObjCnt=0;

   public MipMapper() {}

   /** adds the object to mipmap list */
   public void addObject(Object3D object3d) {
      mipMappedObjs.put(new Integer(object3d.getID()), new ObjectData(object3d));
   }

   /** removes the object from mipmap list */
   public void removeObject(int id) {
      mipMappedObjs.remove(new Integer(id));
   }

   /** creates mipmap textures if they arent already created */
   private void createMipMaps(Object3D object3d) {
      PolygonManager pm=object3d.getPolygonManager();

      for (int polygonId=0; polygonId<pm.getMaxPolygonID(); polygonId++) {
         int textureId=pm.getPolygonTexture(polygonId);

         if (!processedTextures.get(textureId)) {

            Texture texture=tm.getTextureByID(textureId);
            int owidth=texture.getWidth();
            int oheight=texture.getHeight();

            TexelGrabber tg=new TexelGrabber();
            texture.setEffect(tg);
            texture.applyEffect();
            texture.removeEffect();

            int[] texels=tg.texels;

            ColorModel cm=new DirectColorModel(24, 0xFF0000, 0xFF00, 0xFF);
            int[] pixels=new int[owidth*oheight];
            MemoryImageSource source=new MemoryImageSource(owidth, oheight, cm, pixels, 0, owidth);
            Image origTextureImage=Toolkit.getDefaultToolkit().createImage(source);

            Texture lastTexture=texture;
            int lastTextureId=textureId;

            for (int offset=1; offset<LEVELS; offset++) {
               int width=(int) ((float) owidth/Math.pow(2, offset));
               int height=(int) ((float) oheight/Math.pow(2, offset));

               width=Math.max(MIN_SIZE, width);
               height=Math.max(MIN_SIZE, height);

               if ((lastTexture.getWidth()!=width)||(lastTexture.getHeight()!=height)) {

                  if (colorMipmaps) {
                     int[] tmpy=new int[texels.length];
                     int col=200<<(8*((offset-1)%3));
                     for (int i=0; i<tmpy.length; i++) {
                        tmpy[i]=col;
                     }
                     texels=tmpy;
                  }
                  System.arraycopy(texels, 0, pixels, 0, owidth*oheight);
                  source.newPixels();

                  Image mipmapTextureImage=origTextureImage.getScaledInstance(width, height, Image.SCALE_SMOOTH);
                  Texture mipmapTexture=new Texture(mipmapTextureImage);

                  String textureName=getTextureName(textureId, offset);

                  if (tm.containsTexture(textureName))
                     tm.replaceTexture(textureName, mipmapTexture);
                  else tm.addTexture(textureName, mipmapTexture);

                  lastTexture=mipmapTexture;
                  lastTextureId=tm.getTextureID(textureName);

                  textureIds.put(textureName, new Integer(lastTextureId));
                  createdTextures.addElement(textureName);

                  Logger.log("mip map texture created "+textureName+" "+width+"x"+height, Logger.MESSAGE);

               } else {
                  // no need to create a new texture so use last one
                  String textureName=getTextureName(textureId, offset);
                  textureIds.put(textureName, new Integer(lastTextureId));

                  Logger.log("re-used last mipmap texture "+textureName+" "+width+"x"+height, Logger.MESSAGE);
               }

            } // for offset
            processedTextures.set(textureId);
         } // if (!processedTextures.get(textureId)
      } // for polygonId
   }

   private String getTextureName(int baseTextureId, int offset) {
      return "mipmap/"+baseTextureId+"/"+offset;
   }

   /**
    * Does the actual mipmapping based on the current visibility list.
    * Has to be executed after/before rendering/drawing the scene, so it's always
    * "one step behind" but if you don't move very fast, this shouldn't matter.
    */
   public void mipMap(World world, FrameBuffer buffer) {
      if (mipMappedObjs.isEmpty()) {
         return; // no mipMapped objects so return
      }
      if (mipMappedObjs.size()>changedObjects.length) {
         changedObjects=new ObjectData[mipMappedObjs.size()]; // resize on demand
      }

      VisList vl=world.getVisibilityList();

      int size=vl.getSize();
      int lastObjectId=-1;

      ObjectData objectData=null;
      lastObjCnt=0;

      SimpleVector[] v=new SimpleVector[3];
      Camera camera=world.getCamera();

      for (int i=0; i<size; i++) {
         vl.getData(i, visListData);

         if (lastObjectId!=visListData[0]) {
            lastObjectId=visListData[0];
            objectData=(ObjectData) mipMappedObjs.get(new Integer(visListData[0]));
         }

         if (objectData!=null) {
            int polygonId=visListData[1];

            v[0]=Interact2D.project3D2D(camera, buffer, objectData.pm.getTransformedVertex(polygonId, 0));
            v[1]=Interact2D.project3D2D(camera, buffer, objectData.pm.getTransformedVertex(polygonId, 1));
            v[2]=Interact2D.project3D2D(camera, buffer, objectData.pm.getTransformedVertex(polygonId, 2));

            if (v[0]!=null && v[1]!=null && v[2]!=null) {
               float polygonArea=calculateArea(v);
               float ratio=polygonArea/objectData.textureAreas[polygonId];

               int offset=-1;
               boolean done=false;
               while (!done&&(++offset<LEVELS-1)) {
                  done=ratio>FIRST_LEVEL;
                  ratio*=4f;
               }

               int targetTex=objectData.orgTex[polygonId][offset];

               if (targetTex!=objectData.curTex[polygonId]) {
                  if (!objectData.isChanged()) {
                     objectData.setChanged(true);
                     changedObjects[lastObjCnt]=objectData;
                     lastObjCnt++;
                  }
                  objectData.curTex[polygonId]=targetTex;
                  objectData.pm.setPolygonTexture(polygonId, targetTex);
               }
            }
         }
      }
      for (int i=0; i<lastObjCnt; i++) {
         changedObjects[i].recreate();
         changedObjects[i].setChanged(false);
         changedObjects[i]=null;
      }
   }

   /** resets all textures to their original states
    * i.e. disables mip mapping */
   public void reset() {
      for (Enumeration itty=mipMappedObjs.elements(); itty.hasMoreElements(); ) {
         ((ObjectData) itty.nextElement()).reset();
      }
   }

   /**
    * useful for cleanup purposes
    * (i.e you dont want call TextureManager.flush() for whatever reason)
    */
   public void dispose() {
      for (Enumeration itty=createdTextures.elements(); itty.hasMoreElements(); ) {
         String textureName=(String) itty.nextElement();
         if (tm.containsTexture(textureName)) {
            tm.replaceTexture(textureName, tm.getDummyTexture());
         } else {
            Logger.log("couldn't find texture "+textureName, Logger.WARNING);
         }
      }
   }

   private float calculateArea(SimpleVector[] v) {
      float area=v[0].x*v[1].y+v[1].x*v[2].y+v[2].x*v[0].y-(v[0].y*v[1].x+v[1].y*v[2].x+v[2].y*v[0].x);
      area*=0.5;
      return (area<0)?-area:area;
  }


   /** data structure to store polygon data per object */
   private class ObjectData {
      private Object3D object3d;
      private PolygonManager pm;

      private int[][] orgTex;
      private int[] curTex;
      private float[] textureAreas;
      private boolean changed=false;

      private ObjectData(Object3D object3d) {
         this.object3d=object3d;
         pm=object3d.getPolygonManager();

         orgTex=new int[pm.getMaxPolygonID()][LEVELS];
         curTex=new int[pm.getMaxPolygonID()];

         textureAreas=new float[pm.getMaxPolygonID()];

         createMipMaps(object3d);
         SimpleVector[] v=new SimpleVector[3];

         for (int i=0; i<orgTex.length; i++) {
            int textureId=pm.getPolygonTexture(i);

            orgTex[i][0]=textureId;
            for (int offset=1; offset<LEVELS; offset++) {
               orgTex[i][offset]=((Integer) textureIds.get(getTextureName(textureId, offset))).intValue();
            }

            curTex[i]=orgTex[i][0];

            v[0]=pm.getTextureUV(i, 0);
            v[1]=pm.getTextureUV(i, 1);
            v[2]=pm.getTextureUV(i, 2);
            float uvArea=calculateArea(v);
            Texture texture=tm.getTextureByID(textureId);
            textureAreas[i]=uvArea*texture.getWidth()*texture.getHeight();
         }
      }

      private void setChanged(boolean is) {
         changed=is;
      }

      private boolean isChanged() {
         return changed;
      }

      private void recreate() {
         object3d.recreateTextureCoords();
      }

      private void reset() {
         boolean changed=false;
         for (int polygonId=0; polygonId<orgTex.length; polygonId++) {
            int originalTextureId=orgTex[polygonId][0];

            if (originalTextureId!=curTex[polygonId]) {
               changed=true;
               pm.setPolygonTexture(polygonId, originalTextureId);
               curTex[polygonId]=originalTextureId;
            }
         }
         if (changed) {
            object3d.recreateTextureCoords();
         }
      }
   }

   /**
    * small helper class to access a texture's texels.
    */
   private class TexelGrabber implements ITextureEffect {

      private int[] texels=null;

      public void init(Texture tex) {}

	  public boolean containsAlpha() {
		  return false;
      }

      public void apply(int[] dest, int[] source) {
         texels=source;
      }
   }
}