package Current.manage;

import java.applet.Applet;
import java.awt.event.*;
import java.awt.*;
import java.awt.geom.*;
import java.util.*;
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import java.net.URL;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.Serializable;

import org.pat.util.ClassComparator;
import Current.popups.Settings.Items.StringSelector;
import Current.basic.*;

// messages
import Current.*;

// popups
import Current.popups.Grids.GridManager;
import Current.popups.Settings.*;
import Current.popups.ImageSave.ImageSaveManager;
import Current.popups.Deg100.Deg100Interface;

// sub managers
import Current.manage.Popup.*;
import Current.manage.Tiles.*;
import Current.manage.ParameterSpace.*;

/**
 * This class offers a communications channel for different components of
 * McBilliards to talk to each other.
 *
 * There is description of "Howto communicate using the manager"
 * on Pat's website at
 * @link http://math.sunysb.edu/~pat/visual/web_mcb/Current/Howto/manager.html
 */
public class Manager implements ParameterSpaceRenderer {
    
    
    
    //added by Rich
    //Deg100ManagerInterface DMI=new Deg100ManagerInterface();
    
    /////////////// Handles configuring various features in McBilliards
    /////////////// for instance: colors for some popups
    
    public Settings settings;
    
    ///////////////// The MOUSE
    
    /** if mouse=1 we are in 3 button mode, if mouse=0 we are in one button mode */
    public int mouse;
    /** if mouse=0, then emulate button=mode presses for mode equal 1,2,3*/
    public int mode;
    
    
    ///////////////// SUBMANAGERS
    
    public GridManager GM;
    public SpaceTileManager STM;
    //private ParameterManager PM;
    public ParameterSpaceManager PSM;
    public ImageSaveManager ISM;
    public SettingsManager settingsManager;
    public PopupManager PopupM;
    
    // global settings
    public GlobalSettings global;
    
    // debugging settings
    public DebugManagerSettings debug;
    private Debugger debugger;
    
    public Manager() {
        init();
    }
    
    public Manager(Applet A) {
        setCodeBase(A);
        init();
    }
    
    private void init() {
        // set up debugging
        debug=new DebugManagerSettings();
        // set up global settings
        global=new GlobalSettings();
        
        send_thread=new SendThread();
        send_thread.start();
        
        
        // moving to the new form of manager
        listeners=new TreeMap(new ClassComparator());
        
        
        
        debugger=new Debugger(this);
        
        // turn on some caching by default (e.g. colors, parameter space)
        defaultCaching();
        
        
        
        //default to 3 button mouse
        mouse=1;
        // if 1 button mouse default to middle button
        mode=2;
        
        
        // settings
        settings=new Settings(this);
        debug=(DebugManagerSettings)settings.getDefault(DebugManagerSettings.class);
        global=(GlobalSettings)settings.getDefault(GlobalSettings.class);
        
        /// submanagers (order is important)
        //PM=new ParameterManager();
        settingsManager=new SettingsManager(this);
        PSM=new ParameterSpaceManager(this);
        STM=new SpaceTileManager(this);
        GM=new GridManager(this);
        ISM=new ImageSaveManager();
        PopupM=new PopupManager(this);
        
    }
    
    private void defaultCaching() {
        // cache color and fill start with white
        mcbCache(Color.class);
        mcbSend(new Color(255,255,255),true);
        // cache tiles and default to Fagnano word
        mcbCache(Tile.class);
        mcbSend(new SearchTile("123123"),true);
        // cache and save a default viewing rectangle
        mcbCache(ViewingRectangleChange.class);
        mcbSend(new ViewingRectangleChange(new Rectangle2D.Double(0.0,0.0,1.0,1.0)),true);
        // cache and save a default point in the parameter space
        mcbCache(Parameter.class);
        mcbSend(new Parameter(2.0/3,2.0/3),true);
        // cache rational triangles
        mcbCache(RationalTriangle.class);
        mcbSend(new RationalTriangle(1,1,1),true);
        // cache rational line
        mcbCache(RationalLine.class);
        mcbSend(new RationalLine(1,-1,0),true);
        // cache Deg100Interface
        mcbCache(Deg100Interface.class);
        
        // the rest of this ensures that the messages are dealt with before
        // continuing
        
    }
    
    /** wait until no messages are on the stack */
    public void mcbWait() {
        boolean b=false;
        synchronized (send_queue) {
            b=(send_queue.size()==0);
        }
        while (!b) {
            try {
                Thread.currentThread().sleep(10);
            } catch (Throwable T) {
            }
            synchronized (send_queue) {
                b=(send_queue.size()==0);
            }
        }
    }
    
    
    public static class GlobalSettings implements Serializable {
        public String getTitle() {
            return "global settings";
        }
        
        public StringSelector affine_coordinate_scheme;
        public static final String affine_coordinate_scheme_name="Affine Coordinate Scheme";
        
        public GlobalSettings() {
            String[] obtuse_acute={"obtuse", "acute"};
            affine_coordinate_scheme=new StringSelector(obtuse_acute);
        }
    }
    
    
    
    
    
    
    
    
    
    
    public static class DebugManagerSettings implements Serializable {
        public String getTitle() {
            return "debug manager";
        }
        
        
        /** If true print every new word */
        public boolean print_new_words=false;
        public static final String print_new_words_name="print new words";
        
        public boolean send_debugging=false;
        public static final String send_debugging_name="debug mcbSend()";
        
        public boolean verbose_debugging=false;
        public static final String verbose_debugging_name="verbose debugging";        
    }
    
    
    
    public class Debugger {
        
        public Debugger(Manager M) {
            M.addListener(this);
        }
        
        public void mcbReceive(Tile t) {
            if (debug.print_new_words) {
                System.out.println("Current word:\""+t.getStringWord()+"\"");
            }
        }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    public void render(Graphics2D g, java.awt.geom.AffineTransform T) {
        PSM.render(g,T);
    }
    /** Add me to the list of components that render to the canvas
     * I want to draw first! (meaning everything else will draw on top of me
     */
    
    public void addRendererBottom(ParameterSpaceRenderer me) {
        PSM.addRendererBottom(me);
    }
    
    /** Add me to the list of components that render to the canvas
     * I want to draw last! (meaning I draw on top of everything else)
     */
    public void addRendererTop(ParameterSpaceRenderer me) {
        PSM.addRendererTop(me);
    }
    
    
    
    
    
    
    
    
    
    
    
    
    /** return true if the program can write to files. This is impossible
     * if the program is running as an applet. */
    public static boolean canWrite(){
        SecurityManager SM=System.getSecurityManager();
        if (SM==null) {
            //System.out.println("No SecurityManager Present!");
            return true;
        }
        return false;
    }
    
    
    
    
    
    
    
    
    /*************** REMOVAL *******************/
    
    /** This is a function that removes all references of the given object */
    public void remove(Object obj){
        //System.out.println("Manager removing a "+obj.getClass().getName());
        
        // also remove from any sub-managers
        //PSM.remove(obj);
        ISM.remove(obj);
        
        Object o;
        this.removeListener(obj);
        o=null;
    }
    
    ///////////////// determines how you should read files
    // I'm sure there is a better way to do this.
    private boolean is_applet=false;
    private URL codeBase;
    public void setCodeBase(Applet A){
        try {
            codeBase=A.getCodeBase();
            is_applet=true;
        } catch (Throwable T) {
            is_applet=false;
        }
    }
    public boolean isApplet() {
        return is_applet;
    }
    /** throws exceptions if fails */
    public InputStream getInputStream(String file)
    throws java.io.FileNotFoundException,
    java.net.MalformedURLException, java.io.IOException {
        if (is_applet) {
            return (new URL(codeBase,file)).openStream();
        } else {
            return new FileInputStream(file);
        }
    }
    public URL toURL(String file) {
        if (is_applet) {
            try {
                return new URL(codeBase,file);
            } catch (Throwable T) {
                T.printStackTrace();
            }
        }
        try {
            URL url=(new File(file)).toURL();
            //System.out.println("URL="+url);
            return url;
        } catch (Throwable T) {
            T.printStackTrace();
        }
        System.err.println("Warning returning null in getCodeBase()");
        return null;
    }
    
    
    
    /// NEW STUFF....
    /// From here on, we implement the new version of the
    /// Manager class. Eventually, the earlier version will be faded out.
    
    private class ManagerListener {
        public WeakReference wr;
        public Method m;
        
        public ManagerListener(WeakReference wr, Method m) {
            this.wr=wr;
            this.m=m;
        }
        
        public boolean isValid() {
            return (wr.get()!=null);
        }
        
        public Class getType() {
            return m.getParameterTypes()[0];
        }
        
        public void call(Object obj) {
            Object arg[]={obj};
            Object x=wr.get();
            if (x==null) {
                System.err.println("Attempted to invoke method on vanished weak reference!");
                System.err.println("Object type: "+getType());
            } else {
                try {
                    m.invoke(x,arg);
                } catch (Throwable T) {
                    System.err.println("Trouble with calling method "+m);
                    System.err.println("Using object of type "+x.getClass());
                    System.err.println("Applying to object of type "+obj.getClass());
                    T.printStackTrace();
                }
            }
        }
        
    }
    
    private class SafeManagerListener {
        public Object obj;
        public Method m;
        
        public SafeManagerListener(ManagerListener ml) {
            obj=ml.wr.get();
            m=ml.m;
        }
        
        public boolean isValid() {
            return (obj!=null);
        }
        
        public Class getType() {
            return m.getParameterTypes()[0];
        }
        
        public void call(Object parameter) {
            Object arg[]={parameter};
            if (obj==null) {
                System.err.println("Attempted to invoke method on vanished weak reference!");
                System.err.println("Object type: "+getType());
            } else {
                try {
                    m.invoke(obj,arg);
                } catch (Throwable T) {
                    System.err.println("Trouble with calling method "+m);
                    System.err.println("Using object of type "+obj.getClass());
                    System.err.println("Applying to object of type "+obj.getClass());
                    T.printStackTrace();
                }
            }
        }
        
    }
    
    private class ListenerClasses {
        // Linked list of ManagerListeners
        private LinkedList ll=new LinkedList();
        // do you want to cache the object?
        private boolean cache=false;
        // cached object
        private Object cached=null;
        
        public ListenerClasses() {
        }
        
        public void add(ManagerListener ml) {
            synchronized (ll) {
                ll.add(ml);
            }
        }
        
        public void remove(Object obj) {
            synchronized (ll) {
                ManagerListener ml;
                for (Iterator it=ll.iterator(); it.hasNext(); ) {
                    ml=(ManagerListener)(it.next());
                    if (ml.isValid()) {
                        if (ml.wr.get()==obj) {
                            it.remove();
                        }
                    } else {
                        System.err.println("Warning: non-manual removal of a ManagerListener"+
                        " of type "+ml.getType());
                        it.remove();
                    }
                }
            }
        }
        
        private void notifyList(Object msg) {
            LinkedList ll2=new LinkedList();
            SafeManagerListener sml;
            synchronized (ll) {
                for (ListIterator it=ll.listIterator(); it.hasNext();) {
                    sml=new SafeManagerListener((ManagerListener)(it.next()));
                    if (sml.isValid())
                        ll2.add(sml);
                    else {
                        it.remove();
                        System.out.println("warning: removing a listener of type "+sml.getType());
                    }
                }
            }
            for (ListIterator it=ll2.listIterator(); it.hasNext();) {
                sml=(SafeManagerListener)(it.next());
                sml.call(msg);
            }
            // caching ...
            if (cache=true) {
                cached=msg;
            }
        }
    }
    
    
    /** This listeners is arraged by key's of type Class/Interface
     * and values consisting of a linked list of ManagerListeners */
    TreeMap listeners;
    
    /** add this object to the list of those objects
     ** which listen to sent messages */
    public void addListener(Object obj) {
        WeakReference wr=new WeakReference(obj);
        Class c=obj.getClass();
        Method[] meth=c.getMethods();
        for (int i=0; i<meth.length; i++) {
            if ((meth[i].getName().compareTo("mcbReceive")==0)&&
            (meth[i].getParameterTypes().length==1)) {
                Class key=meth[i].getParameterTypes()[0];
                if (listeners.containsKey(key)) {
                    ListenerClasses lc=(ListenerClasses)(listeners.get(key));
                    lc.add(new ManagerListener(wr, meth[i]));
                    //.addLast(new ManagerListener(wr, meth[i]));
                } else {
                    ListenerClasses lc=new ListenerClasses();
                    lc.add(new ManagerListener(wr, meth[i]));
                    listeners.put(key, lc);
                }
                //System.out.println("Added a listener: "+obj.getClass());
            }
        }
    }
    
    private void removeListener(Object obj) {
        Class c=obj.getClass();
        Method[] meth=c.getMethods();
        for (int i=0; i<meth.length; i++) {
            if ((meth[i].getName().compareTo("mcbReceive")==0)&&
            (meth[i].getParameterTypes().length==1)) {
                Class key=meth[i].getParameterTypes()[0];
                if (listeners.containsKey(key)) {
                    ListenerClasses lc=(ListenerClasses)(listeners.get(key));
                    lc.remove(obj);
                }
            }
        }
    }
    
    /** Send the message msg to all objects in the list that have a
     * mcbReceive method to handle objects of the type of msg. */
    public void mcbSend(Object msg) {
        synchronized(send_queue) {
            send_queue.addLast(msg);
        }
        send_thread.interrupt();
    }
    
    /** Send the message msg to all objects in the list that have a
     * mcbReceive method to handle objects of the type of msg.
     * @param wait if true, wait until the message has propagated
     * to all listeners.
     */
    public void mcbSend(Object msg, boolean wait) {
        synchronized(send_queue) {
            send_queue.addLast(msg);
        }
        send_thread.interrupt();
        if (wait)
            mcbWait();
    }
    
    
    /** turn on caching for messages of type message_class.
     * This allows you to use the command "mcbGet(message_class)" to retrieve
     * the most recent message sent in this class.
     */
    public void mcbCache(Class message_class){
        if (! listeners.containsKey(message_class)) {
            ListenerClasses lc=new ListenerClasses();
            listeners.put(message_class,lc);
        }
        ((ListenerClasses)(listeners.get(message_class))).cache=true;
    }
    
    /** returns the most recent message sent in the message_class. In order to
     * use this function, caching must be first turned on with "mcbCache(message_class)."
     * Returns null if caching
     * is turned off, or if no message in the class has been sent since it was
     * turned on.
     * @see Manager.mcbCache(Class) */
    public Object mcbGet(Class message_class){
        if (listeners.containsKey(message_class)) {
            return ((ListenerClasses)(listeners.get(message_class))).cached;
        }
        return null;
    }
    
    /** sets the most recent message sent of type message_class to null.
     * If later you call mcbGet(message_class) you will get null returned.
     */
    public void mcbClearCache(Class message_class){
        if (listeners.containsKey(message_class)) {
            ((ListenerClasses)(listeners.get(message_class))).cached=null;
        }
    }
    
    
    /** If the object obj has a method "void mcbCleanup()", then run the
     * method. The mcbCleanup() function is meant to clean up the relationship
     * between the object and the manager. */
    public static void cleanupObject(Object obj) {
        try {
            Method meth=obj.getClass().getDeclaredMethod("mcbCleanup", (Class[])null);
            meth.invoke(obj,(Object[])null);
        } catch (Throwable T) {
        }
    }
    
    /** The send queue. This eliminates problems with order in mcbSend. */
    
    LinkedList send_queue=new LinkedList();
    SendThread send_thread;
    
    protected class SendThread extends Thread {
        public boolean stop;
        protected boolean sleeping;
        
        public SendThread() {}
        
        public void run() {
            Object msg;
            
            sleeping=false;
            stop=false;
            while (!stop) {
                while (send_queue.size()!=0) {
                    synchronized (send_queue) {
                        msg=send_queue.removeFirst();
                    }
                    if (msg==null) {
                        if (debug.send_debugging)
                            System.out.println("null sent!");
                    } else {
                        if (debug.send_debugging)
                            System.out.println("sending a "+msg.getClass());
                        Class c=msg.getClass();
                        Class[] ifaces=c.getInterfaces();
                        
                        for (int i=0; i<ifaces.length; i++) {
                            if (listeners.containsKey(ifaces[i])) {
                                ((ListenerClasses)(listeners.get(ifaces[i]))).notifyList(msg);
                            }
                        }
                        
                        while (c!=null) {
                            if (listeners.containsKey(c)) {
                                ((ListenerClasses)(listeners.get(c))).notifyList(msg);
                            }
                            c=c.getSuperclass();
                        }
                    }
                }
                
                sleeping=true;
                try {
                    //if (send_debugging)
                    //    System.out.println("trying to sleep");
                    this.sleep(1000);
                } catch (InterruptedException e) {
                    //if (send_debugging)
                    //    System.out.println("Sleep interrupted");
                }
                sleeping=false;
            }
        }
        
        public void interrupt() {
            if (sleeping) {
                super.interrupt();
            }
        }
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    /*** Convenience functions */
    
    /*********** COLORS ************/
    
    /** Process a color change */
    public void setColor(Color C) {
        mcbSend(C);
    }
    
    /** get the current color */
    public Color getColor() {
        return (Color)mcbGet(Color.class);
    }
    
    /************ TILES and WORDS *************/
    
    /** Start thinking about the word w */
    public void setWord(String word) {
        mcbSend(new SearchTile(word));
    }
    
    /** Select the tile T */
    public void selectTile(Tile T) {
        mcbSend(T);
    }
    
    /** plot the tile st */
    public void plotTile(Tile st){
        //System.out.println("Plot Tile");
        //System.out.flush();
        STM.plotTile(st);
        selectTile(st);
    }
    
    /************* Select tiles *************/
    
    /** convenience method to indicate that some subtle change has been made
     * to the currently selected tile (maybe its color was changed). */
    public void selectedTileModified() {
        mcbSend(new TileModified());
    }
    
    /** convenience method to get the current tile */
    public Tile getSelectedTile() {
        return (Tile)(mcbGet(Tile.class));
    }
    
    /** return the current word */
    public String getWord(){
        return ((Tile)(mcbGet(Tile.class))).getStringWord();
    }
    
    /************ Parameter Space ***********/
    
    
    /** notify all components that care, that the rendering of the parameter
     * space has changed (for example, maybe a tile has been added).
     * Generally, such a component would then repaint. */
    public void spaceChanged() {
        mcbSend(new SpaceChange());
    }
    
    /** notify all components that care that the viewing rectangle
     * has changed*/
    public void setViewingRectangle(Rectangle2D.Double rect) {
        mcbSend(new ViewingRectangleChange(rect));
    }
    
    public Rectangle2D.Double getViewingRectangle() {
        return ((ViewingRectangleChange)mcbGet(ViewingRectangleChange.class)).rect;
    }
    
    
    //////////////// The Complex Parameter
    
    /** Call this to change the point in the parameter space */
    public void setParameter(double X, double Y) {
        mcbSend(new Parameter(X,Y));
    }
    
    /** Call this to change the point in the parameter space */
    public void setParameter(Complex Z) {
        mcbSend(new Parameter(Z));
    }
    
    /** Get the current x coordinate in the parameter space */
    public double getX(){
        return ((Parameter)mcbGet(Parameter.class)).getX();
    }
    
    /** Get the current y coordinate in the parameter space */
    public double getY(){
        return ((Parameter)mcbGet(Parameter.class)).getY();
    }
    
    /** Return the current McBilliards coordinate as a complex number */
    public Complex getZ(){
        return ((Parameter)mcbGet(Parameter.class)).getZ();
    }
    
    //////////////////// The Rational Triangle
    
    /** set the rational triangle */
    public void setRationalTriangle(RationalTriangle t) {
        mcbSend(t);
    }
    
    /** get the rational triangle */
    public RationalTriangle getRationalTriangle() {
        return ((RationalTriangle)mcbGet(RationalTriangle.class));
    }
    
    /////////////////// The Rational Line
    
    /** set the rational line */
    public void setRationalLine(RationalLine l) {
        mcbSend(l);
    }
    
    /** get the rational line */
    public RationalLine getRationalLine() {
        return ((RationalLine)mcbGet(RationalLine.class));
    }
    
    //////////// Combined
    /** this avoids two calls to each listener to parameter changes. */
    //public void setParameters(Complex z, RationalTriangle t) {
    //}
}