package game.entry
{
   import flash.utils.Timer;
   import flash.desktop.NativeApplication;
   import flash.display.NativeWindow;
   import lib.engine.sound.fmod.FmodSoundDriver;
   import flash.events.InvokeEvent;
   import engine.core.util.AppInfo;
   import game.view.GameWrapper;
   import engine.core.util.CloudSave;
   import engine.core.util.CloudSaveDefault;
   import engine.core.util.CloudSaveSynchronizer;
   import game.saga.GameSaveSynchronizer;
   import flash.filesystem.File;
   import lib.engine.resource.air.ZipFileResourceScheme;
   import lib.engine.resource.air.FallbackVideoFinder;
   import engine.core.util.StringUtil;
   import engine.resource.loader.SagaURLLoader;
   import engine.resource.ResourceManager;
   import engine.math.Hash;
   import engine.core.logging.ILogger;
   import flash.system.Capabilities;
   import engine.core.analytic.LocMon;
   import engine.core.analytic.Ga;
   import flash.events.Event;
   import flash.events.TimerEvent;
   import flash.utils.getTimer;
   import com.adobe.crypto.MD5;
   import flash.utils.ByteArray;
   import flash.filesystem.FileStream;
   import flash.filesystem.FileMode;
   import engine.gui.core.GuiApplication;
   import lib.engine.util.air.AirAppInfo;
   import lib.engine.util.air.NativeText;
   import game.view.GameDevSocket;
   import game.session.states.VideoState;
   import flash.display.StageQuality;

   public class GameEntryDesktopAir extends GameEntryDesktop
   {

      private var invoked:Boolean;

      private var readyToSetup:Boolean;

      private var exitTimer:Timer;

      private var entryHelper:game.entry.IEntryHelperDesktop;

      public function GameEntryDesktopAir(param1:GuiApplication)
      {
         this.exitTimer = new Timer(500,1);
         super(param1,new AirAppInfo(param1,"2.28.66","2016-04-17_21-54-51","dev",0),FmodSoundDriver,File.userDirectory.url,NativeText,GameDevSocket);
         VideoState.USE_1080_MP4 = true;
         param1.stage.quality = StageQuality.BEST;
         param1.stage.color = 0;
      }

      public function setEntryHelper(param1:game.entry.IEntryHelperDesktop) : void
      {
         this.entryHelper = param1;
         if(param1)
         {
            param1.init(this);
         }
      }

      override public function set windowWidth(param1:int) : void
      {
         var _loc2_:NativeWindow = NativeApplication.nativeApplication.activeWindow;
         if(!_loc2_)
         {
            return;
         }
         _loc2_.x = Math.max(0,_loc2_.x - (param1 - _loc2_.width));
         _loc2_.width = param1;
      }

      override public function set windowHeight(param1:int) : void
      {
         var _loc2_:NativeWindow = NativeApplication.nativeApplication.activeWindow;
         if(!_loc2_)
         {
            return;
         }
         _loc2_.y = Math.max(0,_loc2_.y - (param1 - _loc2_.height));
         _loc2_.height = param1;
      }

      override public function set fmodDebug(param1:Boolean) : void
      {
         FmodSoundDriver._debug = param1;
      }

      public function invokeHandler(param1:InvokeEvent) : void
      {
         logInfo("INVOKE reason=[" + param1.reason + "] arguments=[" + param1.arguments + "]");
         if(this.invoked)
         {
            return;
         }
         if(AppInfo.terminating)
         {
            return;
         }
         this.invoked = true;
         logInfo("INVOKE approot=[" + appInfo.nativeAppUrlRoot + "]");
         var _loc3_:String = param1.currentDirectory.nativePath;
         logInfo("INVOKE CWD=[" + _loc3_ + "]");
         invokeArguments = param1.arguments;
         this.readyToSetup = true;
         var _loc4_:Boolean = doSetup();
         if(_loc4_)
         {
            this.startGa();
            this.verifyChecksums();
            if(AppInfo.terminating)
            {
               return;
            }
            logInfo("Starting game");
            this.startGame();
         }
      }

      override protected function initWrapper(param1:int, param2:Array) : GameWrapper
      {
         var _loc3_:* = wrappers.length == param1;
         var _loc4_:GameWrapper = super.initWrapper(param1,param2);
         if(Boolean(_loc3_) && Boolean(this.entryHelper))
         {
            this.entryHelper.initWrapper(_loc4_);
         }
         return _loc4_;
      }

      override protected function handleDoSetup() : Boolean
      {
         var _loc1_:Boolean = super.handleDoSetup();
         if(_loc1_)
         {
            if(this.entryHelper)
            {
               this.entryHelper.setup();
            }
         }
         return _loc1_;
      }

      override protected function startGame() : void
      {
         var _loc1_:CloudSave = null;
         var _loc3_:GameWrapper = null;
         if(this.entryHelper)
         {
            _loc1_ = this.entryHelper.initCloudSave(wrappers[0].config,appInfo);
            betaBranch = this.entryHelper.betaBranch;
            userId = this.entryHelper.userId;
         }
         else
         {
            _loc1_ = new CloudSaveDefault("none",null);
         }
         var _loc2_:CloudSaveSynchronizer = new CloudSaveSynchronizer(appInfo.logger);
         if(_loc2_)
         {
            _loc2_.registerCloudSave(_loc1_);
            GameSaveSynchronizer.instance.init(wrappers[0].config,_loc2_);
         }
         this.setupZipAssets();
         super.startGame();
         var _loc4_:int = 0;
         while(_loc4_ < wrappers.length)
         {
            _loc3_ = wrappers[_loc4_];
            if(this.entryHelper)
            {
               this.entryHelper.startWrapper(_loc3_,_loc4_);
            }
            _loc4_++;
         }
      }

      private function setupZipAssets() : void
      {
         var _loc1_:File = null;
         var _loc2_:String = null;
         var _loc3_:ZipFileResourceScheme = null;
         var _loc4_:FallbackVideoFinder = null;
         if(StringUtil.endsWith(assetsUrl,".zip"))
         {
            _loc1_ = new File(assetsUrl);
            _loc2_ = StringUtil.getFilename(assetsUrl);
            appInfo.logger.info("Zip file " + _loc1_.nativePath);
            _loc3_ = new ZipFileResourceScheme(appInfo.logger);
            _loc3_.registerZipFile(assetsUrl,_loc1_);
            SagaURLLoader.registerSchema("zip",_loc3_);
            _loc3_.setupForVideo();
            assetsUrl = "zip:/" + _loc2_;
            _loc4_ = new FallbackVideoFinder(_loc3_,assetsUrl);
            ResourceManager.videoURLTransform = _loc4_;
         }
      }

      override protected function startGa() : void
      {
         var _loc9_:* = null;
         var _loc10_:Boolean = false;
         var _loc1_:String = Hash.DJBHash(appInfo.macAddress).toString(16);
         var _loc2_:String = appInfo.buildVersion;
         var _loc3_:ILogger = appInfo.logger;
         var _loc4_:String = appInfo.ini["google_uid"];
         var _loc5_:Vector.<String> = null;
         if(_loc4_)
         {
            _loc9_ = "tbs/" + sku;
            if(locally)
            {
               _loc9_ = _loc9_ + "/locally";
            }
            else if(Boolean(this.entryHelper) && (Boolean(_loc5_ = this.entryHelper.getAnalyticsInfo())))
            {
               _loc9_ = _loc9_ + _loc5_[0];
               _loc1_ = Hash.DJBHash(_loc5_[1]).toString(16);
            }
            else
            {
               _loc9_ = _loc9_ + "/unknown";
               _loc10_ = true;
            }
            if(Boolean(Capabilities.isDebugger) || Boolean(developer) || Boolean(sagaHappening))
            {
               _loc9_ = _loc9_ + "/developer";
            }
            LocMon.init(_loc3_,_loc2_,_loc1_);
            Ga.init(appInfo,_loc3_,_loc4_,_loc9_,_loc2_,_loc1_);
            if(_loc10_)
            {
               this.startGa_reportUnknown();
            }
         }
         var _loc6_:int = Capabilities.screenResolutionX;
         var _loc7_:int = Capabilities.screenResolutionY;
         var _loc8_:String = Capabilities.language;
         Ga.trackSessionStart(_loc6_,_loc7_,_loc8_);
      }

      private function startGa_reportUnknown() : void
      {
         var _loc3_:String = null;
         var _loc1_:uint = Hash.DJBHash(appInfo.macAddress);
         Ga.trackEvent("unknown","user",StringUtil.getBasename(File.userDirectory.url),_loc1_);
         var _loc2_:int = 0;
         while(_loc2_ < invokeArguments.length)
         {
            _loc3_ = invokeArguments[_loc2_];
            Ga.trackEvent("unknown","invoke_arg",_loc3_,_loc1_);
            _loc2_++;
         }
         Ga.trackEvent("unknown","os",Capabilities.os,_loc1_);
         Ga.trackEvent("unknown","mac_address",appInfo.macAddress,_loc1_);
         Ga.trackEvent("unknown","build",appInfo.buildVersion,_loc1_);
         Ga.trackEvent("unknown","appdir",appInfo.applicationDirectoryUrl_native,_loc1_);
      }

      public function closingHandler(param1:Event) : void
      {
         logInfo("GameEntryDesktopAir.closingHandler");
      }

      public function exitingHandler(param1:Event) : void
      {
         logInfo("GameMainAir.exitingHandler autoExit=" + NativeApplication.nativeApplication.autoExit + ", event=" + param1);
         AppInfo.terminating = true;
         handleExit();
         param1.preventDefault();
         this.exitTimer.addEventListener(TimerEvent.TIMER_COMPLETE,this.exitTimerCompleteHandler);
         this.exitTimer.start();
      }

      private function exitTimerCompleteHandler(param1:TimerEvent) : void
      {
         logInfo("exitTimerCompleteHandler");
         NativeApplication.nativeApplication.exit(appInfo.exitCode);
      }

      override protected function processArgument(param1:String) : Boolean
      {
         if(this.entryHelper)
         {
            if(this.entryHelper.processArgument(param1))
            {
               return true;
            }
         }
         return super.processArgument(param1);
      }

      private function verifyChecksums() : void
      {
         var start:int = 0;
         var steamworksAneContext_library_swf:String = null;
         var steamworksAneContext_catalog_xml:String = null;
         var end:int = 0;
         var delta:int = 0;
         var gamesave_bin_txt:String = null;
         var swf_md5:String = null;
         var worldserpent:String = null;
         var input_1:String = null;
         var input_md5_1:String = null;
         var os:String = Capabilities.os;
         if(!os || os.indexOf("Windows") != 0)
         {
            return;
         }
         var rp:String = File.applicationDirectory.nativePath;
         if(!rp)
         {
            throw new ArgumentError("no nativepath");
         }
         rp = rp.replace(/\\/g,"/");
         if(!StringUtil.endsWith(rp,"/"))
         {
            rp = rp + "/";
         }
         if(Capabilities.isDebugger)
         {
            rp = "C:/Program Files (x86)/Steam/SteamApps/common/tbs2/win32/";
         }
         try
         {
            start = getTimer();
            gamesave_bin_txt = this.readChecksumFile("Front-Buffer subsystem M",rp + "gamesave.bin");
            gamesave_bin_txt = gamesave_bin_txt.replace("\n","");
            gamesave_bin_txt = gamesave_bin_txt.replace("\r","");
            swf_md5 = this.verifyChecksum("Front-Buffer subsystem W",rp + "app.game-" + appInfo.sku + ".air.swf",null);
            logInfo("Front-Buffer " + (getTimer() - start));
            worldserpent = "zabbawabba";
            input_1 = swf_md5 + "\r\n" + worldserpent;
            input_md5_1 = MD5.hash(input_1);
            logInfo("INVOKE entry recursion timestamp [" + swf_md5 + "]");
            if(input_md5_1 != gamesave_bin_txt)
            {
               throw new ArgumentError("Bitswizzle I/O/D error on evaluation of quest parameters");
            }
            this.verifyChecksum("Back-Buffer subsystem Z",rp + "steam_appid.txt","0");
            this.verifyChecksum("Back-Buffer subsystem Y",rp + "tbs_config.ini","4b1702756792ee383b9a3359ac9de7b3");
            this.verifyChecksum("Back-Buffer subsystem A",rp + "AudioFX.dll","5e05c532a87ae596567cd3731ca25c15");
            steamworksAneContext_library_swf = "150278a3f1fcdbcc3855eac8e4d32ea0";
            steamworksAneContext_catalog_xml = "150278a3f1fcdbcc3855eac8e4d32ea0";
            steamworksAneContext_library_swf = "efca2ff3d3d91830e5910ade6037ae7c";
            steamworksAneContext_catalog_xml = "55572fa131ad48c362aafb9ce72e9d6a";
            this.verifyChecksum("Back-Buffer subsystem G",rp + "META-INF/AIR/extensions/air.steamworks.ane.SteamworksAneContext/library.swf",steamworksAneContext_library_swf);
            this.verifyChecksum("Back-Buffer subsystem J",rp + "META-INF/AIR/extensions/air.steamworks.ane.SteamworksAneContext/META-INF/ANE/Windows-x86/library.swf",steamworksAneContext_library_swf);
            this.verifyChecksum("Back-Buffer subsystem H",rp + "META-INF/AIR/extensions/air.steamworks.ane.SteamworksAneContext/catalog.xml",steamworksAneContext_catalog_xml);
            this.verifyChecksum("Back-Buffer subsystem I",rp + "META-INF/AIR/extensions/air.steamworks.ane.SteamworksAneContext/META-INF/ANE/extension.xml","38786f21049f9a0741ac67646f7ff351");
            this.verifyChecksum("Back-Buffer subsystem K",rp + "META-INF/AIR/extensions/air.steamworks.ane.SteamworksAneContext/META-INF/ANE/Windows-x86/NativeSteamworks.dll","c10cf1fa21773aac3458b4ba6392093d");
            end = getTimer();
            delta = end - start;
            logInfo("Game saga unpack " + delta + " ms");
            return;
         }
         catch(e:Error)
         {
            appInfo.terminateError("Game saga unpacking encountered termination: " + e);
            return;
         }
      }

      private function readChecksumFile(param1:String, param2:String) : String
      {
         var _loc3_:File = new File(param2);
         if(!_loc3_.exists)
         {
            throw new ArgumentError("Bitswizzle I/O/M error on " + param1);
         }
         var _loc4_:ByteArray = new ByteArray();
         var _loc5_:FileStream = new FileStream();
         _loc5_.open(_loc3_,FileMode.READ);
         var _loc6_:String = _loc5_.readUTFBytes(_loc5_.bytesAvailable);
         _loc5_.close();
         return _loc6_;
      }

      private function verifyChecksum(param1:String, param2:String, param3:String, param4:Boolean = false) : String
      {
         logDebug(":::: " + param2);
         var _loc5_:* = param3 == "0";
         var _loc6_:File = new File(param2);
         if(!_loc6_.exists)
         {
            if(_loc5_)
            {
               return null;
            }
            if(!param4)
            {
               throw new ArgumentError("Bitswizzle I/O error on " + param1);
            }
            return null;
         }
         if(_loc5_)
         {
            throw new ArgumentError("Bitswizzle I/O error on " + param1);
         }
         var _loc7_:ByteArray = new ByteArray();
         var _loc8_:FileStream = new FileStream();
         _loc8_.open(_loc6_,FileMode.READ);
         _loc8_.readBytes(_loc7_,0,_loc8_.bytesAvailable);
         _loc8_.close();
         _loc8_ = null;
         var _loc9_:String = MD5.hashBytes(_loc7_);
         if(param3)
         {
            if(_loc9_ != param3)
            {
               throw new ArgumentError("Bitswizzle overflow error on " + param1 + " [" + _loc9_ + "]");
            }
         }
         return _loc9_;
      }
   }
}