package de.roboshock.gui.util;

import java.awt.Container;
import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.HeadlessException;
import java.awt.Point;
import java.awt.Toolkit;
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;

import javax.swing.JFrame;


public class PositionKeepingJFrame extends JFrame {

	private static final long serialVersionUID = 1L;

	public PositionKeepingJFrame() throws HeadlessException {
		super();
	}

	public PositionKeepingJFrame(GraphicsConfiguration gc) {
		super(gc);
	}

	public PositionKeepingJFrame(String title, GraphicsConfiguration gc) {
		super(title, gc);
	}

	public PositionKeepingJFrame(String title) throws HeadlessException {
		super(title);
	}

	public void addMainPanel(Container p) {
		setContentPane(p);
		//getContentPane().add(p);
	}
	
    public void setVisible(boolean b) {
    	if (isVisible() && ! b) {
    		storeVisibleState(b);
    		storePosition();
    	}

		super.setVisible(b);
		
		if (b) {
//			restorePosition(100, 100);
    		storeVisibleState(b);
		}
    }

    public void setVisibleWithoutRemembering(boolean b) {
		super.setVisible(b);
    }

    public void restorePosition(int defaultWidth, int defaultHeight) {
    	
    	//System.out.println("PositionKeepingJFrame.restorePosition for: "+getTitle());
		// load
		Preferences prefs = Preferences.userNodeForPackage(PositionKeepingJFrame.class);
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        Dimension frameSize = this.getSize(); // the default, if nothing is stored
        
        frameSize.width = prefs.getInt(getTitle() + ".w", defaultWidth);
        frameSize.height = prefs.getInt(getTitle() + ".h", defaultHeight);
        frameSize.width = min(frameSize.width, screenSize.width -20);
        frameSize.height = min(frameSize.height, screenSize.height -20);
        setSize(frameSize);

        int x = prefs.getInt(getTitle() + ".x", (screenSize.width - frameSize.width) / 2);
		int y = prefs.getInt(getTitle() + ".y", (screenSize.height - frameSize.height) / 2);
		
		setLocationInsideScreen(new Point(x,y));
		//System.out.println("setting "+getTitle()+": " +x+"  "+y);
    }

    private void setLocationInsideScreen(Point preferredLocation) {
    	Dimension frameSize = this.getSize();
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    	Point ret = new Point(preferredLocation);
		if (ret.x < 0) ret.x = 0;
		if ((ret.x + frameSize.width > screenSize.width)) {
			ret.x = screenSize.width - frameSize.width;
		}
		if (ret.y < 0) ret.y = 0;
		if ((ret.y + frameSize.height > screenSize.height)) {
			ret.y = screenSize.height - 30 - frameSize.height;
		}
    	
    	this.setLocation(ret);
    }
    
    private int min(int a, int b) {
    	if (a < b) return a;
    	return b;
    }
    
    private int max(int a, int b) {
    	if (a > b) return a;
    	return b;
    }
    
    public void storePosition() {
    	if (! isVisible()) return;
    	
    	//System.out.println("storing "+getTitle()+": "+getX()+"  "+getY());
		Preferences prefs = Preferences.userNodeForPackage(PositionKeepingJFrame.class);
		prefs.putInt(getTitle() + ".x", getX());
		prefs.putInt(getTitle() + ".y", getY());
		prefs.putInt(getTitle() + ".w", getWidth());
		prefs.putInt(getTitle() + ".h", getHeight());
		try {
			prefs.sync();
		}
		catch (BackingStoreException ex) { ex.printStackTrace(); }
    }
    
    public void storeVisibleState() {
    	storeVisibleState(isVisible());
    }
    
    private void storeVisibleState(boolean visible) {
		Preferences prefs = Preferences.userNodeForPackage(PositionKeepingJFrame.class);
		prefs.putBoolean(getTitle() + ".v", visible);
		try {
			prefs.sync();
		}
		catch (BackingStoreException ex) { ex.printStackTrace(); }
    }
    
    public void restoreVisibleState() {
		Preferences prefs = Preferences.userNodeForPackage(PositionKeepingJFrame.class);
    	//super.setVisible(prefs.getBoolean(getTitle() + ".v", true));
    	setVisible(prefs.getBoolean(getTitle() + ".v", true));
    }
    
}