////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You under the Apache License, Version 2.0
//  (the "License"); you may not use this file except in compliance with
//  the License.  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////
package {

import flash.display.DisplayObject;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.events.Event;
import flash.system.Capabilities;
import flash.filesystem.File;

[Mixin]
/**
 *  Location of a hash table of tests not to run. 
 *  This mixin should find the excludes written to one of two locations.
 *  Browsers runs are picky about where they find the excludes, so, we serve them 
 *  up via http (in a sibling location to the tests). 
 *  The file is one test per line of the form ScriptName$TestID
 *  The location of the file is assumed to be c:/temp on windows, 
 *  or /tmp on Unix. 
 */
public class ExcludeFileLocationApollo
{

	private static var loader:URLLoader;

	private static var url:String;
	private static var mustellaTestDir:String;

	private static var frontURL:String;
	private static var domain:String;

	public static var excludeFile:String = "ExcludeList.txt";	

	/**
	 * tell UnitTester it should wait for this load to complete
	 */
	UnitTester.waitForExcludes = true;


	public static var _root:DisplayObject;


	public static var triedBrowser:Boolean = false;
	public static var triedNormal:Boolean  = false;

	// we try the http spot, in case this is a browser run
	public static function init(root:DisplayObject):void
	{

		trace ("Hello from excludes at: " + new Date());

        _root = root;
            
        // set up callback to load excludes after 
        // UnitTester has initialized.
        UnitTester.loadExcludeFile = loadExcludeFile;   
        
	}


    public static function loadExcludeFile():void
    {
        var os:String = Capabilities.os;
        
        // This seems to be a timing issue which pops up on some machines.
        if( UnitTester.cv == null ){
            UnitTester.cv = new ConditionalValue();
        }
        
        if( (UnitTester.cv.os != null) && (UnitTester.cv.os.toLowerCase() == DeviceNames.ANDROID.toLowerCase()) ){
            mustellaTestDir = "..";
            excludeFile = UnitTester.excludeFile;
            trace("Doing Android style exclude.  Checking in " + mustellaTestDir + "/" + excludeFile);
        }else if( (UnitTester.cv.os != null) && (UnitTester.cv.os.toLowerCase() == DeviceNames.IOS.toLowerCase()) ){
            mustellaTestDir = File.documentsDirectory.url;
            excludeFile = UnitTester.excludeFile;
        }else if (os.indexOf ("QNX") > -1) {
            mustellaTestDir = "..";
            excludeFile = UnitTester.excludeFile;
            trace("Doing QNX style exclude.  Checking in " + mustellaTestDir + "/" + excludeFile);
        }
        else{
            
            if (os.indexOf ("Windows") != -1) 
            {
                excludeFile = "ExcludeListWinAIR.txt";
            } else if (os.indexOf ("Mac") != -1) 
            {
                excludeFile = "ExcludeListMacAIR.txt";
            } else if (os.indexOf ("Linux") != -1) 
            {
                excludeFile = "ExcludeListLinux.txt";
            } else 
            {		
                trace ("Excludes: bad: we didn't see an OS we liked: " + os);
                excludeFile = "ExcludeListWin.txt";
            }
            
            url = _root.loaderInfo.url;
            
            if (url.indexOf("app:")!=-1) 
            {
                ApolloFilePath.init (_root);
                url = encodeURI2(ApolloFilePath.apolloAdjust(url));
                trace ("Adjusting path for AIR to: " + url);
                // url = adjustPath(url);
            }
            
            // allow application to override mustella test dir
            if (!UnitTester.mustellaTestDir)
                mustellaTestDir = url.substring (0, url.indexOf ("mustella/tests")+14);
            else
                mustellaTestDir = UnitTester.mustellaTestDir;
            
            frontURL = url.substring (0, url.indexOf (":"));
            domain = url.substring (url.indexOf (":")+3);		
            domain = domain.substring (0, domain.indexOf ("/"));
        }
        
        loadTryNormal();
        
    }

    private static function apolloAdjust(url:String):String
	{

		var swf:String = _root.loaderInfo.url;
		var f:File = new File (swf);
		// clean it up: 
		var myPattern:RegExp = /\\/g; 
		var path:String = f.nativePath;
		path = path.replace (myPattern, "/");
		path = path.replace (":", "|");
		// yank off the swfs directory, which we're in
		path = path.substr (0, path.lastIndexOf ("/")-1);
		path = path.substr (0, path.lastIndexOf ("/"));

		if (url.indexOf ("../")==0)
			url = url.substring (2);

		if (url.indexOf ("/..")==0)
		{
			url = url.substring (3);
			path = path.substr (0, path.lastIndexOf ("/"));
		}

		/// create the final url
		path = path + url;

		return "file:///" + path;
	}

	public static var adjustPath:Function = function(url:String):String { return url; };


        private static function encodeURI2(s:String):String
        {
                var pos:int = s.lastIndexOf("/");
                if (pos != -1)
                {
                        var fragment:String = s.substring(pos + 1);
                        s = s.substring(0, pos + 1);
                        fragment= encodeURIComponent(fragment);
                        s = s + fragment;
                }
                return s;
        }


	public static function loadTryBrowser():void
	{
		trace ("excludes loadTryBrowser at: " + new Date().toString());

		triedBrowser = true;

		var currentOS:String = Capabilities.os;

		var useFile:String = "http://localhost/" + excludeFile;

		trace ("try excludes from here: " + useFile);

		var req:URLRequest = new URLRequest(useFile);
		loader = new URLLoader();
		loader.addEventListener("complete", completeHandler);
		loader.addEventListener("securityError", errorHandler);
		loader.addEventListener("ioError", errorHandler);
		loader.load(req);

	}

	/// if it worked, all good
	private static function completeHandler(event:Event):void
	{
		trace ("Excludes: from web server");
		postProcessData(event);
	}


	/**
	 *  A non-browser will get its results from the /tmp location. 
 	 *  It should be a failure to get here; we try the browser case first
	 *  because it throws a nasty seciry
	 *  
	 */
	public static function errorHandler(event:Event):void
	{ 
	
		trace ("Exclude: in the web read error handler");
		if (!triedNormal) 
		{
			loadTryNormal();	

		}

	}
	public static function loadTryNormal():void
	{

		triedNormal = true;

		trace ("excludes loadTryFile " + new Date().toString());

		var currentOS:String = Capabilities.os;

		var useFile:String;

		useFile = mustellaTestDir +"/" + excludeFile;

		trace ("Exclude: try load from: " + useFile);

		var req:URLRequest = new URLRequest(useFile);
		loader = new URLLoader();
		loader.addEventListener("complete", completeHandler2);
		loader.addEventListener("ioError", errorHandler2);
		loader.addEventListener("securityError", errorHandler2);
		loader.load(req);

	}

	private static function errorHandler2(event:Event):void
	{
		trace ("Exclude: error in the exclude file load " +event);	
		if (!triedBrowser) 
		{
			loadTryBrowser();
		}

	}


	private static function completeHandler2(event:Event):void
	{
		trace ("Excludes: Reading from file system at "+mustellaTestDir );
		postProcessData(event);
	}
	private static function postProcessData(event:Event):void
	{
		var data:String = loader.data;
		// DOS end of line
		var delimiter:RegExp = new RegExp("\r\n", "g");
		data = data.replace(delimiter, ",");
		// Unix end of line
		delimiter = new RegExp("\n", "g");
		data = data.replace(delimiter, ",");

		UnitTester.excludeList = new Object();
		var items:Array = data.split(",");
		var n:int = items.length;
		for (var i:int = 0; i < n; i++)
		{
			var s:String = items[i];
			if (s.length)
				UnitTester.excludeList[s] = 1;

		}
		
		UnitTester.waitForExcludes = false;
		UnitTester.pre_startEventHandler(event);
	}
}

}