/*
Copyright 2002 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/

import java.lang.ref.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.awt.*;
import java.util.*;

public class ImageJob extends CacheRef implements java.io.Serializable{

  private static final long serialVersionUID = Version.getSUID();

  public static double SCALEFACT = 2;

  public int index;
  public double scale;
  public Segment seg;
  public AffineTransform trans;
  AffineTransform rtrans;

  transient HashSet users = new HashSet();;

  public transient boolean pending = false;

  public ImageJob(Segment seg,int index) {
//    file.fragments.add(this);
    this.seg = seg;
    this.index = index;
    
    scale = 1;
    for (int i=0;i<index;i++) scale *= SCALEFACT;

    rtrans = (AffineTransform)seg.map.overlaytrans.clone();
    rtrans.scale(1/scale,1/scale);
  }
  
  public boolean equals(Object that) {
    return((that instanceof ImageJob) &&
           ((ImageJob)that).seg == seg &&
           ((ImageJob)that).index == index);
  }

  public int hashCode() {
    return(seg.hashCode() + index);
  }

  public boolean check() {
    return(rtrans!=null && (trans!=null || ref==null));
  }

  public String toString() {
    return(seg.getName()+" index = "+index+" scale = "+scale);
  }

  public void setImage(BufferedImage image) {
    if (image!=null && getTrans()!=null) {
      set(image);
    }
  }
  

  public AffineTransform getTrans() {
    if (trans != null) return(trans);

    if (rtrans==null) {
      rtrans = (AffineTransform)seg.map.overlaytrans.clone();
      rtrans.scale(1/scale,1/scale);
    }

    Rectangle2D bounds = seg.getBounds(rtrans);
    try {
      trans = rtrans.createInverse();
    } catch (Exception e) {
      ErrorLog.exception(e,"Error reducing segment "+seg.name);
      ref = null;
      return(null);
    }
    trans.translate(bounds.getX(),bounds.getY());
    return(trans);
  }


/*
  private void readObject(java.io.ObjectInputStream stream)
      throws java.io.IOException,java.lang.ClassNotFoundException {
    stream.defaultReadObject();
    size = new Point2D.Double(stream.readDouble(),stream.readDouble());
  }

  private void writeObject(java.io.ObjectOutputStream stream)
      throws java.io.IOException,java.lang.ClassNotFoundException {
    stream.defaultWriteObject();
    stream.writeDouble(size.getX());
    stream.writeDouble(size.getY());
  }
*/

  public void addUser(Component user) {
    if (isReady()) user.repaint();
    else
      if (users==null) users = new HashSet();
      synchronized(users) {
        users.add(new TransparentWeakReference(user));
      }
  }

  public boolean load() {

    seg.solve();

    if (index!=0 && Segment.dobig)
      seg.cookers[0].load();

    if (!lock(true)) {

      for (int s=index-1;s>=0;s--) {
        BufferedImage big = (BufferedImage)seg.cookers[s].get();
        if (big!=null) {
          int fact = 1<<(index-s);
          int w = big.getWidth()/fact;
          int h = big.getHeight()/fact;
          BufferedImage res = new BufferedImage(w,h,BufferedImage.TYPE_INT_ARGB);
          Raster bigrast = big.getRaster();
          WritableRaster small = res.getRaster();
          int[] pixel = null;
          for (int i=0;i<w;i++)
            for (int j=0;j<h;j++) {
              pixel = bigrast.getPixel(i*fact,j*fact,pixel);
              small.setPixel(i,j,pixel);
            }
          big=null;
          bigrast=null;
          small=null;

          setImage(res);

//          Rectangle2D bounds = seg.getBounds(rtrans);
//          try {
//            trans = rtrans.createInverse();
//          } catch (Exception e) {
//            ErrorLog.exception(e,"Error reducing segment "+seg.name);
//            ref = null;
//            return(false);
//          }
//          trans.translate(bounds.getX(),bounds.getY());
//
//          set(res);
          lock(true);
          res=null;

          break;
        }
      }
    
      if (!lock(true)) {

        Image rawimage=seg.isource.getImage();
        
        Rectangle2D bounds = seg.getBounds(rtrans);
        
        if (Double.isInfinite(bounds.getWidth()) || Double.isNaN(bounds.getWidth())) {
          System.out.println("bad width "+bounds.getWidth());
          ErrorLog.log("bad width "+bounds.getWidth());
          ref=null;
          return(false);
        }


        BufferedImage res = null;
        try {

          res = seg.map.getImage(rawimage,rtrans,bounds,seg.boundary,
        			 seg.name+" (%"+(int)(100/scale)+" size) ",seg.transparent);
      
//          trans = rtrans.createInverse();
//          trans.translate(bounds.getX(),bounds.getY());
      
//        } catch (OutOfMemoryError e) {
//          ErrorLog.exception(e,"Out of memory morphing segment "+seg.name);
//          ref = null;
//          return(false);
        } catch (Exception e) {
          ErrorLog.exception(e,"Error morphing segment "+seg.name);
          ref = null;
          return(false);
        } finally { 
          CartoFrame.message.setText("");
          rawimage = null;
        }
        setImage(res);
        lock(true);
        res = null;
      }
    }

    if (Segment.thumbs) {
      if (index<Segment.levels-1) {
        seg.cookers[Segment.levels-1].load();
        seg.cookers[Segment.levels-1].lock(false);
      }
      else
        seg.thumbnail = (BufferedImage)get();
    }
    
    if (users!=null)
      synchronized(users) {
        ImageThread.addUsers(users);
        users.clear();
      }
    
//    System.out.println("load done");
    return(true);
  }

  static Color[] dbgcolors = {Color.RED,Color.GREEN,Color.BLUE,Color.YELLOW,Color.PINK};
  static int dbgcnt = 0;

  public boolean isReady() {
    return(ref!=null);
  }
}