package {

    import flash.display.Sprite;
    import fl.motion.AdjustColor;
    import flash.filters.ColorMatrixFilter;
    import fl.events.SliderEvent;
    import fl.controls.Slider;
    import flash.display.DisplayObject;
    import fl.controls.Button;
    import fl.events.ComponentEvent;
    import fl.controls.Label;
    import flash.net.SharedObject;

    public class ICAdjustColor extends Sprite
    {
        private var my_AdjustColor:AdjustColor = new AdjustColor();
        private var my_ColorMatrixFilter:ColorMatrixFilter;

        private var my_Slider_IC_BRIGHTNESS:Slider = new Slider();
        private var my_Slider_IC_CONTRAST:Slider = new Slider();
        private var my_Slider_IC_HUE:Slider = new Slider();
        private var my_Slider_IC_SATURATION:Slider = new Slider();

        private var my_Button_save:Button = new Button();
        private var my_Button_revert:Button = new Button();

        private var my_soName:String;

        private var my_DO:DisplayObject;

        private var my_IC_BRIGHTNESS:Number = new Number();
        private var my_IC_CONTRAST:Number = new Number();
        private var my_IC_HUE:Number = new Number();
        private var my_IC_SATURATION:Number = new Number();

        private var my_sliderMagFactor:Number = new Number();

        public function ICAdjustColor(theDO:DisplayObject, soName:String, theSliderMagFactor:Number):void
        {
            trace("ICAdjustColor ctor(2): soName="+soName);
            my_soName = soName;
            my_DO = theDO;
            my_sliderMagFactor = theSliderMagFactor;
            init(my_soName);
        }

        public function addChildren()
        {
            addChild(my_Slider_IC_BRIGHTNESS);
            addChild(my_Slider_IC_CONTRAST);
            addChild(my_Slider_IC_HUE);
            addChild(my_Slider_IC_SATURATION);
            trace("my_Button_save: " + my_Button_save.toString());
            addChild(my_Button_save);
            addChild(my_Button_revert);

            /* Add Listeners function */

            addListeners();
        }

        private final function addListeners():void
        {
            my_Slider_IC_BRIGHTNESS.addEventListener(SliderEvent.CHANGE, adjustBrightness);
            my_Slider_IC_CONTRAST.addEventListener(SliderEvent.CHANGE, adjustContrast);
            my_Slider_IC_HUE.addEventListener(SliderEvent.CHANGE, adjustHue);
            my_Slider_IC_SATURATION.addEventListener(SliderEvent.CHANGE, adjustSaturation);
            my_Button_save.addEventListener(ComponentEvent.BUTTON_DOWN, saveHandler);
            my_Button_revert.addEventListener(ComponentEvent.BUTTON_DOWN, revertHandler);
        }

        private final function saveHandler(e:ComponentEvent):void
        {
            trace("** saveHandler: begins: my_soName="+my_soName);
            var SO = SharedObject.getLocal(my_soName);
            trace("-- SO.client="+SO.client);

            for (var prop1 in SO.data) {
                trace("-- saveHandler: before set: prop1: "+prop1+": "+SO.data[prop1]);
            }

            SO.data.IC_BRIGHTNESS           = my_IC_BRIGHTNESS  / my_sliderMagFactor;
            SO.data.IC_CONTRAST             = my_IC_CONTRAST    / my_sliderMagFactor;
            SO.data.IC_HUE                  = my_IC_HUE         / my_sliderMagFactor;
            SO.data.IC_SATURATION           = my_IC_SATURATION  / my_sliderMagFactor;

            for (var prop2 in SO.data) {
                trace("-- saveHandler: after set: prop2: "+prop2+": "+SO.data[prop2]);
            }

            SO.data.IC_HUE = my_IC_SATURATION / my_sliderMagFactor;
            trace("-- saveHandler: my_IC_HUE:" + my_IC_HUE + " SO.data.IC_HUE:" + SO.data.IC_HUE);

            SO.flush();
        }

        private final function revertHandler(e:ComponentEvent):void
        {
            trace("*** revertHandler: begins: my_soName="+my_soName);
            trace("revertHandler: set SO vals to 0");

            var SO = SharedObject.getLocal(my_soName);

            SO.clear();

            SO.data.IC_BRIGHTNESS = 0;
            SO.data.IC_CONTRAST = 0;
            SO.data.IC_HUE = 0;
            SO.data.IC_SATURATION = 0;

            my_IC_BRIGHTNESS = SO.data.IC_BRIGHTNESS;
            my_IC_CONTRAST = SO.data.IC_CONTRAST;
            my_IC_HUE = SO.data.IC_HUE;
            my_IC_SATURATION = SO.data.IC_SATURATION;

            //SO.setDirty("IC_HUE");

            trace("revertHandler: call init with new SO vals");
            init(my_soName);
            trace("revertHandler: ends");
        }

        // initialize based on soName (eg, stream name)
        public final function init(soName:String):void
        {

            my_soName = soName;

            var SO = SharedObject.getLocal(my_soName);

            trace("ICAdjustColor: init: begin: my_soName="+my_soName);
            trace("ICAdjustColor: init: begin: SO.data.IC_HUE="+SO.data.IC_HUE);

            // IF SO EXISTS, USE, ELSE, INIT TO 0
            if(SO.data.IC_BRIGHTNESS!=undefined) { my_IC_BRIGHTNESS = SO.data.IC_BRIGHTNESS;
            } else {
                my_IC_BRIGHTNESS = 0;
            }
            if(SO.data.IC_CONTRAST!=undefined) {
                my_IC_CONTRAST = SO.data.IC_CONTRAST;
            } else {
                my_IC_CONTRAST = 0;
            }
            if(SO.data.IC_HUE!=undefined) {
                trace("-- SO.data.IC_HUE!=undefined, use SO val="+ SO.data.IC_HUE);
                my_IC_HUE = SO.data.IC_HUE;
            } else {
                trace("-- SO.data.IC_HUE==undefined, st my_IC_HUE = 99");
                my_IC_HUE = 99;
            }
            if(SO.data.IC_SATURATION!=undefined) {
                my_IC_SATURATION = SO.data.IC_SATURATION;
            } else {
                my_IC_SATURATION = 0;
            }

            // TRACE ALL SO VALUES
            for (var prop in SO.data) {
                trace("-- init: loop set: "+prop+": "+SO.data[prop]);
                switch(prop) {
                    case "IC_HUE":
                        trace("---- case: IC_HUE");
                        my_IC_HUE = SO.data[prop];
                        break;
                    case "IC_BRIGHTNESS" :
                        trace ("---- case IC_BRIGHTNESS");
                        break;
                    case "IC_CONTRAST" :
                        trace ("---- case IC_CONTRAST");
                        break;
                    case "IC_SATURATION" :
                        trace ("---- case IC_SATURATION");
                        break;
                }
            }

            //trace("set my_AdjustColor values");
            my_AdjustColor['brightness'] = my_IC_BRIGHTNESS;
            my_AdjustColor['contrast'] = my_IC_CONTRAST;
            my_AdjustColor['hue'] = my_IC_HUE;
            my_AdjustColor['saturation'] = my_IC_SATURATION;

            //trace("set slider min/max ranges");
            my_Slider_IC_BRIGHTNESS.minimum = -100;
            my_Slider_IC_BRIGHTNESS.maximum = 100;
            my_Slider_IC_CONTRAST.minimum = -100;
            my_Slider_IC_CONTRAST.maximum = 100;
            my_Slider_IC_HUE.minimum = -100;
            my_Slider_IC_HUE.maximum = 100;
            my_Slider_IC_SATURATION.minimum = -100;
            my_Slider_IC_SATURATION.maximum = 100;

            //trace("set slider values");
            my_Slider_IC_BRIGHTNESS.value = my_IC_BRIGHTNESS;
            my_Slider_IC_CONTRAST.value = my_IC_CONTRAST;
            my_Slider_IC_HUE.value = my_IC_HUE;
            my_Slider_IC_SATURATION.value = my_IC_SATURATION;

            //trace("set slider move positions");
            my_Slider_IC_BRIGHTNESS.move(20, 40);
            my_Slider_IC_CONTRAST.move(20, 60);
            my_Slider_IC_HUE.move(20, 80);
            my_Slider_IC_SATURATION.move(20, 100);

            //trace("set save button");
            my_Button_save.move(20, 120);
            my_Button_save.width = 60;
            my_Button_save.height = 20;

            //trace("set revert button");
            my_Button_revert.move(20, 140);
            my_Button_revert.width = 60;
            my_Button_revert.height = 20;

            my_Button_save.label = "Save";
            my_Button_revert.label = "Revert";

            //trace("store values in SO");
            SO = SharedObject.getLocal(my_soName);
            SO.data.IC_BRIGHTNESS = my_IC_BRIGHTNESS;
            SO.data.IC_CONTRAST = my_IC_CONTRAST;
            SO.data.IC_HUE = my_IC_HUE;
            SO.data.IC_SATURATION = my_IC_SATURATION;

            trace("ICAdjustColor: init ends");

        }

        private final function adjustSetting(name:String, val:Object, slider:Object, e:SliderEvent, soData:Object)
        {
            trace("adjustSetting");
/*
            trace("adjustSetting "+name+" init: val.x="+val.x);
            val.x = e.target.value * my_sliderMagFactor;
            soData = e.target.value * my_sliderMagFactor;
            update();
            trace("adjustSetting "+name+" ends: val.x="+val.x);

            example usage:
            var val:Object = new Object();
            val.x = my_IC_BRIGHTNESS;
            var slider:Object = new Object();
            slider.x = my_IC_BRIGHTNESS;
            var so:Object = new Object();
            so.x = my_IC_BRIGHTNESS;
            adjustSetting("Brightness", slider, so, e, soData)

*/
        }
        private final function adjustBrightness(e:SliderEvent):void
        {
            //Select the local shared object
            var SO = SharedObject.getLocal(my_soName);
            trace("-- adjustBrightness init: my_IC_BRIGHTNESS="+my_IC_BRIGHTNESS);
            my_IC_HUE = e.target.value * my_sliderMagFactor;
            //check if previously set
            if(SO.data.IC_HUE!=undefined){
                //if set, use stored val
                my_AdjustColor['brightness'] = SO.data.IC_BRIGHTNESS;
            } else { // else, if not set, set it to user value
                my_AdjustColor['brightness'] = e.target.value * my_sliderMagFactor;
                update();
            }
            trace("-- adjustBrightness ends: my_IC_BRIGHTNESS="+my_IC_BRIGHTNESS);
        }

        private final function adjustContrast(e:SliderEvent):void
        {
            //Select the local shared object
            var SO = SharedObject.getLocal(my_soName);
            trace("adjustContrast init: SO.data.IC_CONTRAST="+SO.data.IC_CONTRAST);
            my_IC_HUE = e.target.value * my_sliderMagFactor;
            //check if previously set
            if(SO.data.IC_CONTRAST!=undefined){
                //if set, use stored val
                my_AdjustColor['contrast'] = SO.data.IC_CONTRAST;
            } else { // else, if not set, set it to user value
                my_AdjustColor['contrast'] = e.target.value * my_sliderMagFactor;
                update();
            }
            trace("adjustContrast ends: SO.data.IC_CONTRAST="+SO.data.IC_CONTRAST);
        }

        private final function adjustHue(e:SliderEvent):void
        {
            //Select the local shared object
            var SO = SharedObject.getLocal(my_soName);
            trace("- adjustHue init: my_soName="+my_soName+" my_IC_HUE="+my_IC_HUE+" SO.data.IC_HUE="+SO.data.IC_HUE);
            my_IC_HUE = e.target.value * my_sliderMagFactor;
            //check if previously set
            if(SO.data.IC_HUE!=undefined){
                //if set, use stored val
                trace("--- adjustHue: SO.data.IC_HUE!=undefined");
                my_AdjustColor['hue'] = SO.data.IC_HUE;
            } else { // else, if not set, set it to user value
                trace("--- adjustHue: SO.data.IC_HUE==undefined");
                my_AdjustColor['hue'] = e.target.value * my_sliderMagFactor;
                update();
            }

            for (var prop1 in SO.data) {
                trace("--- adjustHue: loop: "+prop1+": "+SO.data[prop1]);
            }

            trace("-- adjustHue ends: my_IC_HUE="+my_IC_HUE+" SO.data.IC_HUE="+SO.data.IC_HUE);
        }

        private final function adjustSaturation(e:SliderEvent):void
        {
            //Select the local shared object
            var SO = SharedObject.getLocal(my_soName);
            trace("adjustSaturation init: my_IC_SATURATION="+my_IC_SATURATION);
            my_IC_HUE = e.target.value * my_sliderMagFactor;
            //check if previously set
            if(SO.data.IC_HUE!=undefined){
                //if set, use stored val
                my_AdjustColor['sat'] = SO.data.IC_SATURATION;
            } else { // else, if not set, set it to user value
                my_AdjustColor['sat'] = e.target.value * my_sliderMagFactor;
                update();
            }
            trace("adjustSaturation ends: my_IC_SATURATION="+my_IC_SATURATION);
        }

        private final function update():void
        {
            my_ColorMatrixFilter = new ColorMatrixFilter(my_AdjustColor.CalculateFinalFlatArray());
            my_DO.filters = [my_ColorMatrixFilter];
        }
    }
}