/*
Copyright (c) 2004-2006 Joseph Gleason

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Current versions of this and other code can be downloaded at:
http://gleason.cc/

*/
package cc.glsn.v15;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.image.BufferedImage;
import java.util.HashMap;
import java.util.Random;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.swing.JPanel;


public class FancyImageZ extends JPanel
{
    
    private static final long serialVersionUID = -163603888220587398L;
    
    int Width;
    int Height;
    int PassNo;
    
    
    Area DamageZone;

    Color Background;



    
    private TreeMap<Integer,HashMap<String,ImageData> > AllImages;
    private TreeMap<Integer,HashMap<String,ImageData> > ReImages;
    
    BufferedImage Img;
    
    
    
    public FancyImageZ(int W, int H)
    {
        this(W,H,Color.BLACK);
    }
    
    public FancyImageZ(int W, int H, Color Back)
    {
        this.Width=W;
        this.Height=H;
        
        //Img=(BufferedImage) createImage(Width, Height);
        
        Img=new BufferedImage(W,H,BufferedImage.TYPE_4BYTE_ABGR);
        
        Img.createGraphics();
        
        setBackground(Back);
        Background=Back;
        AllImages=new TreeMap<Integer,HashMap<String,ImageData> >();
        
        addDamage(new Rectangle(0,0,W,H));
        
        
    }

    protected synchronized void paintComponent(Graphics g)
    {
        Rectangle R=g.getClip().getBounds();
        //System.out.println("Clip:" + g.getClip());

        Graphics2D g2=(Graphics2D)g;
        if (PassNo==0)
        {
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setRenderingHint(RenderingHints.KEY_RENDERING,
                    RenderingHints.VALUE_RENDER_QUALITY);
            
            BufferedImage bimg=(BufferedImage) createImage(Width, Height);
            Graphics2D g3;
            g3 = bimg.createGraphics();
            g3.setBackground(getBackground());
            g3.clearRect(0, 0, Width, Height);
            g3.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                RenderingHints.VALUE_ANTIALIAS_ON);
            g3.setRenderingHint(RenderingHints.KEY_RENDERING,
                                RenderingHints.VALUE_RENDER_QUALITY);
            
            g2.drawImage(bimg,0,0,this);
               

            
        }
        PassNo++;        
        
        drawFancyImage(Img.createGraphics());
        

        g.drawImage(Img.getSubimage(R.x,R.y,R.width,R.height),R.x,R.y,R.width,R.height,null);
    }
    
    /*public void paintComponent(Graphics g) 
    {
        if (!FakeBig)
        {
            addDamage(g.getClip());
        }
        System.out.println("Damage: " + g.getClip());
        
        Graphics2D g2=(Graphics2D)g;
        if (PassNo==0)
        {
            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            g2.setRenderingHint(RenderingHints.KEY_RENDERING,
                    RenderingHints.VALUE_RENDER_QUALITY);
            
            BufferedImage bimg=(BufferedImage) createImage(Width, Height);
            Graphics2D g3;
            g3 = bimg.createGraphics();
            g3.setBackground(getBackground());
            g3.clearRect(0, 0, Width, Height);
            g3.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                RenderingHints.VALUE_ANTIALIAS_ON);
            g3.setRenderingHint(RenderingHints.KEY_RENDERING,
                                RenderingHints.VALUE_RENDER_QUALITY);
            
            g2.drawImage(bimg,0,0,this);
               

            
        }
        PassNo++;
        //Dimension d = getSize();
        //Graphics2D g2 = createGraphics2D(d.width, d.height);
        drawFancyImage(g2);
        //g2.dispose();
        
        //g3.drawImage(bimg, 0, 0, this);
    }*/
    
    public synchronized void updateChanges()
    {
        if (DamageZone!=null)
        {
            //repaint(DamageZone.getBounds());
            repaint();
        }
        
        
    }
    

    private synchronized void drawFancyImage(Graphics2D g2) 
    {
        
        if (DamageZone!=null)
        {
            g2.setColor(Background);
            g2.fill(DamageZone);
        }
        
        if (ReImages!=null)
        {
            
          
            int ReCnt=countObs(ReImages);
            int TotCnt=countObs(AllImages);
            //System.out.println("Drawing " + ReCnt + " of " + TotCnt);
            for (HashMap<String,ImageData> HM : ReImages.values())
            {
                for (ImageData od : HM.values())
                {

                    g2.drawImage(od.I, od.getAT(), null);
                    
                }
            }
            
            
            ReImages=null;
        
        }
        
        DamageZone=null;
    


    }
    
    private synchronized void addDamage(Shape R)
    {
        //System.out.println("Damage: " + R);
        if (ReImages==null)
        {
            ReImages=new TreeMap<Integer,HashMap<String,ImageData> >();
        }
        if (DamageZone==null)
        {
            DamageZone=new Area();
            
        }
        
        
        Rectangle RR=R.getBounds();
        
        
        if ((RR.x==0) && (RR.y==0) && (RR.width==Width) && (RR.height==Height))
        {
            DamageZone=new Area(RR);
            ReImages=AllImages;
            return;
        }
        
        DamageZone.add(new Area(R.getBounds2D()));
        //DamageZone.add(new Area(R));

        
        
        
        for (HashMap<String,ImageData> HM : AllImages.values())
        {
            for (ImageData od : HM.values())
            {
                
                
                if (R.intersects(od.getArea().getBounds2D()))
                {
                    if (!ReImages.containsKey(od.Level))
                    {
                        ReImages.put(od.Level,new HashMap<String,ImageData>(16,0.5f));
                    }   
                    ReImages.get(od.Level).put(od.Name,od);
                    
                    
                    if (!DamageZone.contains(od.getArea().getBounds2D()))
                    {
                        addDamage(od.getArea());
                    }
                    
                    
                    
                }
                
            }
        }
        
        //repaint(R.getBounds());
        
    }
    
    public synchronized void removeImage(String Name)
    {
        for (int Level : AllImages.keySet())
        {
            removeImage(Level,Name);
        }
        
    }
    
    public synchronized void removeImage(int Level, String Name)
    {
        if (AllImages.containsKey(Level))
        {
        
            ImageData OldData=AllImages.get(Level).remove(Name);
            if (OldData!=null)
            {
                addDamage(OldData.getArea());
            }
            
        }
        if ((ReImages!=null) && ReImages.containsKey(Level))
        {
            ImageData OldData=ReImages.get(Level).remove(Name);
            
        }
        
    }
    
    public synchronized void addImage(int Level, String Name, BufferedImage I, int x, int y, double a)
    {
        Random R=new Random();
        ImageData od=new ImageData(Level,Name);
        od.x=x;
        od.y=y;
        od.I=I;
        od.Angle=a*Math.PI/180.0;
        
        if (!AllImages.containsKey(Level))
        {
            AllImages.put(Level,new HashMap<String,ImageData>(16,0.5f));
        }
        
        ImageData OldData=AllImages.get(Level).get(Name);
        
        
        if (od.equals(OldData))
        {
            
        }
        else
        {
        
            AllImages.get(Level).put(Name,od);
            addDamage(od.getArea());
            
            if (OldData!=null)
            {
                addDamage(OldData.getArea());
            }
        }
    
    }
    
    public void addImage(int Level, String Name, BufferedImage I, int x, int y)
    {
        addImage(Level,Name,I,x,y,0.0);
    }
    
    public void addImage(int Level, String Name, BufferedImage I, Point P,double a)
    {
        addImage(Level,Name,I,P.x,P.y,a);
    }
    public void addImage(int Level, String Name, BufferedImage I, Point P)
    {
        addImage(Level,Name,I,P.x,P.y,0.0);
    }
    
    public void addImageCenter(int Level, String Name, BufferedImage I, Point P,double a)
    {
        addImageCenter(Level,Name,I,P.x,P.y,a);
    }
    public void addImageCenter(int Level, String Name, BufferedImage I, Point P)
    {
        addImageCenter(Level,Name,I,P.x,P.y,0.0);
    }

    public void addImageCenter(int Level, String Name, BufferedImage I, int x, int y)
    {
        addImageCenter(Level,Name,I,x,y,0.0);
    }    
    public void addImageCenter(int Level, String Name, BufferedImage I, int x, int y,double a)
    {
        x=x - I.getWidth()/2;
            
            
        y=y - I.getHeight()/2;
        
        addImage(Level,Name,I,x,y,a);
        
    }    
        
    
    private class ImageData
    {
        int Level;
        String Name;
        int x;
        int y;
        double Angle;
        BufferedImage I;
        
        private Area S;
        private AffineTransform AT;
        
        public ImageData(int level, String name)
        {
            Level=level;
            Name=name;
            
        }
        
        public Area getArea()
        {
            if (S==null)
            {
                S=new Area(new Rectangle(0,0,I.getWidth(),I.getHeight()));
                S.transform(getAT());
            }
            
            return S;
            
        }
        
        public AffineTransform getAT()
        {
            if (AT==null)
            {
                
                AT = AffineTransform.getTranslateInstance(x,y);
                
                // add rotation component to it
                if (Angle!=0.0)
                {
                    AT.rotate(Angle,0.5*I.getWidth(), 0.5*I.getHeight());
                }
                
            }
            return AT;
            
        }
        
        public boolean equals(Object O)
        {
           if (O==null) return false;
           
           if (O instanceof ImageData)
           {
               ImageData ID=(ImageData)O;
               if (ID.x!=x) return false;
               if (ID.y!=y) return false;
               if (ID.Angle!=Angle) return false;
               if (I!=ID.I) return false;
               return true;
               
           }
           return false;
            
        }
    }
    

    /** Used by some layout managers */
    public Dimension getMaximumSize()
    {
        return getPreferredSize();
    }

    /** Used by some layout managers */
    public Dimension getMinimumSize()
    {
        return getPreferredSize();
    }

    /** Used by some layout managers */
    public Dimension getPreferredSize()
    {
        return new Dimension(Width,Height);
    }


    public int countObs(SortedMap<Integer,HashMap<String,ImageData> > Z)
    {
        int Cnt=0;
        synchronized(Z)
        {
            for (HashMap<String,ImageData> HM : Z.values())
            {
                for (ImageData od : HM.values())
                {
                    Cnt++;
                    
                }
            }
            
        }
        return Cnt;
        
    }

    public void simplify(int max)
    {
        BufferedImage BI=new BufferedImage(Width,Height,BufferedImage.TYPE_4BYTE_ABGR);
        Rectangle R=new Rectangle(0,0,Width,Height);
        Graphics2D G=BI.createGraphics();
        
        //G.setColor(Background);
        G.fillRect(0,0,Width,Height);

        SortedMap<Integer,HashMap<String,ImageData> > SimMap;
        
        
        
        
        synchronized(AllImages)
        {
            SimMap = new TreeMap<Integer,HashMap<String,ImageData> >(AllImages.subMap(0,max+1));
            
            for (Integer I : SimMap.keySet())
            {
                AllImages.remove(I);
                
            }
            
        }
        
        
        
        for (HashMap<String,ImageData> HM : SimMap.values())
        {
            for (ImageData od : HM.values())
            {
                
                AffineTransform at = AffineTransform.getTranslateInstance(od.x,od.y);
                
                // add rotation component to it
                if (od.Angle!=0.0)
                {
                    at.rotate(od.Angle,0.5*od.I.getWidth(), 0.5*od.I.getHeight());
                }
                G.drawImage(od.I, at, null);
                
            }
        }
        
        G.dispose();
        
            

        addImage(max,"simp",BI,new Point(0,0));

        //System.exit(0);


        
    }
    
    
}