package NET.worlds.console;

import NET.worlds.core.IniFile;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Toolkit;
import java.util.StringTokenizer;

public class GammaFrameState implements MainCallback {
   private static final int defaultWidth = 568;
   private static final int defaultHeight = 424;
   private static final int minimumWidth = 142;
   private static final int minimumHeight = 106;
   private static int[] frameState = new int[5];
   private static GammaFrame frame;
   private static int handle;
   private static String borderKey;
   private static final String layoutKey = "ShaperLayout";
   private static final String modeKey = "ChangeVideoMode";
   private static final float scale = 100.0F;
   private boolean initMaximized;
   private int[] videoMode;

   GammaFrameState(GammaFrame f) {
      frame = f;
      if (borderKey == null) {
         borderKey = Gamma.shaperEnabled() ? "ShaperWindow" : "Window";
      }

      this.restoreBorder();
      int[] mode = new int[2];
      if (strToInts(IniFile.gamma().getIniString("ChangeVideoMode", ""), mode) == 2) {
         this.videoMode = mode;
      }

      Main.register(this);
   }

   public static void saveBorder() {
      int state;
      if (handle != 0 && !isIconic(state = getFrameState())) {
         Point loc = frame.getLocation();
         Dimension size = new Dimension(Window.getWindowWidth(handle), Window.getWindowHeight(handle));
         int[] newState = new int[frameState.length];
         if (!isMaximized(newState[4] = state)) {
            newState[0] = loc.x;
            newState[1] = loc.y;
            newState[2] = size.width;
            newState[3] = size.height;
         } else {
            for (int i = 0; i < 4; i++) {
               newState[i] = frameState[i];
            }
         }

         for (int i = 0; i < frameState.length; i++) {
            if (newState[i] != frameState[i]) {
               IniFile var10000 = IniFile.gamma();
               String var10001 = makeKey(borderKey);
               frameState = newState;
               var10000.setIniString(var10001, intsToStr(newState));
               break;
            }
         }
      }
   }

   private void restoreBorder() {
      if (strToInts(IniFile.gamma().getIniString(makeKey(borderKey), ""), frameState) == 5) {
         if (frameState[0] >= 0 && frameState[2] >= 142 && frameState[1] >= 0 && frameState[3] >= 106) {
            if (isMaximized(frameState[4])) {
               this.initMaximized = true;
            } else {
               frameState[4] = 0;
               this.initMaximized = false;
            }

            frame.reshape(frameState[0], frameState[1], frameState[2], frameState[3]);
         } else {
            this.makeDefaultBorder();
         }
      } else {
         this.makeDefaultBorder();
      }
   }

   private void makeDefaultBorder() {
      Dimension size = getScreenSize();
      int dx = size.width - 568;
      int dy = size.height - 424;
      if (dx <= 0) {
         dx = 0;
      } else {
         dx /= 2;
      }

      if (dy <= 0) {
         dy = 0;
      } else {
         dy /= 2;
      }

      frameState[0] = dx;
      frameState[1] = dy;
      frameState[2] = 568;
      frameState[3] = 424;
      frameState[4] = 0;
      this.initMaximized = false;
      frame.reshape(dx, dy, 568, 424);
   }

   public static void saveLayout(int[] layout, float[] divider, boolean oneTile) {
      IniFile.gamma().setIniString(makeKey("ShaperLayout"), intsToStr(layout) + " " + floatsToStr(divider) + " " + (oneTile ? "0" : "1"));
   }

   public static boolean restoreLayout(int[] argLayout, float[] argDivider) {
      int[] layout = new int[argLayout.length];
      float[] divider = new float[argDivider.length];
      int[] tmp = new int[layout.length + divider.length + 1];
      tmp[layout.length + divider.length] = 0;
      if (strToInts(IniFile.gamma().getIniString(makeKey("ShaperLayout"), ""), tmp) < layout.length + divider.length) {
         return true;
      } else {
         int[] used = new int[layout.length];

         for (int i = 0; i < layout.length; i++) {
            try {
               used[layout[i] = tmp[i]]++;
            } catch (ArrayIndexOutOfBoundsException var8) {
               return true;
            }
         }

         for (int i = 0; i < layout.length; i++) {
            if (used[i] != 1) {
               return true;
            }
         }

         for (int ix = 0; ix < divider.length; ix++) {
            float f = tmp[ix + layout.length] / 100.0F;
            if (f < 0.0F || f > 1.0F) {
               return true;
            }

            divider[ix] = f;
         }

         System.arraycopy(layout, 0, argLayout, 0, argLayout.length);
         System.arraycopy(divider, 0, argDivider, 0, argDivider.length);
         return tmp[layout.length + divider.length] == 0;
      }
   }

   private static int getFrameState() {
      return Window.getWindowState(handle);
   }

   public static boolean isIconic() {
      return handle != 0 ? isIconic(getFrameState()) : false;
   }

   private static boolean isIconic(int state) {
      return state == 1;
   }

   private static boolean isMaximized(int state) {
      return state == 2;
   }

   private static Dimension getScreenSize() {
      return Toolkit.getDefaultToolkit().getScreenSize();
   }

   private static String makeKey(String prefix) {
      Dimension screenSize = getScreenSize();
      return prefix + screenSize.width + "X" + screenSize.height;
   }

   private static String intsToStr(int[] arr) {
      String s = "" + arr[0];

      for (int i = 1; i < arr.length; i++) {
         s = s + " " + arr[i];
      }

      return s;
   }

   private static String floatsToStr(float[] arr) {
      int[] iarr = new int[arr.length];

      for (int i = 0; i < arr.length; i++) {
         iarr[i] = (int)(arr[i] * 100.0F);
      }

      return intsToStr(iarr);
   }

   private static int strToInts(String s, int[] arr) {
      if (s == null) {
         return 0;
      } else {
         StringTokenizer tok = new StringTokenizer(s, " ");

         int i;
         for (i = 0; i < arr.length && tok.hasMoreTokens(); i++) {
            try {
               arr[i] = Integer.parseInt(tok.nextToken());
            } catch (NumberFormatException var5) {
               break;
            }
         }

         return i;
      }
   }

   @Override
   public void mainCallback() {
      handle = Window.findWindow(frame.getTitle());
      if (handle != 0) {
         if (this.videoMode != null) {
            Window.setVideoMode(handle, this.videoMode[0], this.videoMode[1]);
         } else if (this.initMaximized) {
            Window.setWindowState(handle, 2);
         }

         Main.unregister(this);
      }
   }
}