/*
Copyright 2002 by Ralph Hartley
This software is licenced under the terms of the
Gnu Public Licence
*/
import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;
import java.lang.ref.*;

public class ImageThread extends Thread {

  static LinkedList newjobs = new LinkedList();
  static HashMap jobset = new HashMap();
  static ImageThread thread = null;

  ImageJob currentjob = null;

  public static HashSet users = new HashSet();
  public static int paintcnt = 0;
  public static int paintinterval = 0;

  public boolean kill = false;

  ImageThread() {}

//  public static void startLoad(Segment seg, int index, double size, Component user) {
//    startLoad(new ImageJob(seg,size,user));
//  }

//  public static boolean isPending(ImageJob job) {
//    synchronized(newjobs) {
//      return(newjobs.contains(job));
//    }
//  }

  public static void showState() {
    if (thread!=null)
      System.out.println("current = "+thread.currentjob);
    System.out.println("set = "+jobset);
//    System.out.println("queue = "+newjobs);
  }

  public static void stopLoading() {
    synchronized(newjobs) {
      newjobs = new LinkedList();
      jobset = new HashMap();
      synchronized(users) {
        users = new HashSet();
      }
      if (thread!=null) {
        ImageThread temp = thread;
        thread = null;
        temp.kill = true;
        temp.interrupt();
      }
    }
  }

  public static ImageJob startLoad(ImageJob job,Component user) {
    if (user!=null) job.addUser(user);
    synchronized(newjobs) {
      if (job.isReady()) {
        if (user!=null) addUser(user);
        return(job);
      }

//      showState();
//      if (job.pending) return;
      if (jobset.containsKey(job)) return((ImageJob)jobset.get(job));

//      System.out.println("new job = "+job+" isready = "+job.isReady());

      if (job.getTrans()==null) return(job);
//      job.pending = true;
//      System.out.println("add job ="+job);
      newjobs.addLast(job);
      jobset.put(job,job);
//      System.out.println("Q = "+newjobs.size());

//      job = null;
      if (thread==null) {
        thread = new ImageThread();
        thread.setPriority(thread.getPriority()-1);
        thread.start();
      }
      if (thread.currentjob==null) newjobs.notify();
      return(job);
    }
  }

  public static void paintUsers() {
    synchronized (users) {
      for (Iterator it = users.iterator();it.hasNext();) {
        Object item = ((WeakReference)it.next()).get();
        Component user = null;
        if (item instanceof Component)
          user = (Component)item;
        if (user!=null) user.repaint();
      }
      users.clear();
      paintcnt = 0;
    }
  }

  public static void addUsers(HashSet newusers) {
    synchronized (users) {
      users.addAll(newusers);
      if (paintcnt++ >= paintinterval)
        paintUsers();
    }
  }

  public static void addUser(Object user) {
    synchronized (users) {
      users.add(user);
      if (paintcnt++ >= paintinterval)
        paintUsers();
    }
  }

  public static ImageJob loadNow(ImageJob job) {
    synchronized(newjobs) {
      if (thread!=null && job.equals(thread.currentjob))
        synchronized(thread.currentjob) {
          if (thread.currentjob.lock(true)) return(thread.currentjob);
          try {
            thread.currentjob.wait();
            return(thread.currentjob);
          } catch (InterruptedException ex) {}
        }
      else {
        if (jobset.containsKey(job)) {
          newjobs.remove(job);
          jobset.remove(job);
//          job.pending = false;
        }
        
        job.load();
      }
      if (job.lock(true)) return(job);
      else return(null);
    }
  }

  public void run() {
//    System.out.println("Imagethread start");

    while (kill==false) {

      try {
        // Get the next fragment to build. Wait if none.
        synchronized(newjobs) {
          if (currentjob!=null) {
            jobset.remove(currentjob);
//            currentjob.pending = false;
            currentjob = null;
          }
          
          while (newjobs.size()==0) {
//          System.out.println("Waiting for jobs");
            paintUsers();
            try {
              newjobs.wait();
            } catch (InterruptedException ex) {
              if (kill) return;
            }
          }
          currentjob = (ImageJob)newjobs.getFirst();
          newjobs.remove(0);
//        System.out.println("doing job "+currentjob+" Q after = "+newjobs.size());
        }
        
        yield();
        
        synchronized(currentjob) {
          currentjob.load();
          currentjob.notify();
        }
      } catch (RuntimeException ex) {
        ErrorLog.exception(ex,"Error int Image thread");
      }
      
//      System.out.println("all jobs done");
//      yeald();
    }
  }
}