/// <reference path="../_definitions.ts" />

/**
* Phaser - Display - Texture
*
* The Texture being used to render the object (Sprite, Group background, etc). Either Image based on a DynamicTexture.
*/

module Phaser.Display {

    export class Texture {

        /**
         * Creates a new Texture component
         * @param parent The object using this Texture to render.
         * @param key An optional Game.Cache key to load an image from
         */
        constructor(parent) {

            this.game = parent.game;
            this.parent = parent;

            this.canvas = parent.game.stage.canvas;
            this.context = parent.game.stage.context;
            this.alpha = 1;
            this.flippedX = false;
            this.flippedY = false;

            this._width = 16;
            this._height = 16;

            this.cameraBlacklist = [];
            this._blacklist = 0;

        }

        /**
         * Camera Blacklist length
         */
        private _blacklist: number;

        /**
         * Private _width - use the width getter/setter instead
         */
        private _width: number;

        /**
         * Private _height - use the height getter/setter instead
         */
        private _height: number;

        /**
         * Reference to Phaser.Game
         */
        public game: Phaser.Game;

        /**
         * Reference to the parent object (Sprite, Group, etc)
         */
        public parent;

        /**
         * Reference to the Image stored in the Game.Cache that is used as the texture for the Sprite.
         */
        public imageTexture = null;

        /**
         * Reference to the DynamicTexture that is used as the texture for the Sprite.
         * @type {DynamicTexture}
         */
        public dynamicTexture: Phaser.Display.DynamicTexture = null;

        /**
        * The load status of the texture image.
        * @type {bool}
        */
        public loaded: bool = false;

        /**
         * An Array of Cameras to which this texture won't render
         * @type {Array}
         */
        public cameraBlacklist: number[];

        /**
         * Whether the texture background is opaque or not. If set to true the object is filled with
         * the value of Texture.backgroundColor every frame. Normally you wouldn't enable this but
         * for some effects it can be handy.
         * @type {bool}
         */
        public opaque: bool = false;

        /**
        * Opacity of the Sprite texture where 1 is opaque (default) and 0 is fully transparent.
        * @type {number}
        */
        public alpha: number;

        /**
         * The Background Color of the Sprite if Texture.opaque is set to true.
         * Given in css color string format, i.e. 'rgb(0,0,0)' or '#ff0000'.
         * @type {string}
         */
        public backgroundColor: string = 'rgb(255,255,255)';

        /**
         * You can set a globalCompositeOperation that will be applied before the render method is called on this Sprite.
         * This is useful if you wish to apply an effect like 'lighten'.
         * If this value is set it will call a canvas context save and restore before and after the render pass, so use it sparingly.
         * Set to null to disable.
         */
        public globalCompositeOperation: string = null;

        /**
        * A reference to the Canvas this Sprite renders to.
        * @type {HTMLCanvasElement}
        */
        public canvas: HTMLCanvasElement;

        /**
        * A reference to the Canvas Context2D this Sprite renders to.
        * @type {CanvasRenderingContext2D}
        */
        public context: CanvasRenderingContext2D;

        /**
         * The Cache key used for the Image Texture.
         */
        public cacheKey: string;

        /**
         * The Texture being used to render the Sprite. Either an Image Texture from the Cache or a DynamicTexture.
         */
        public texture;

        /**
         * Controls if the Sprite is rendered rotated or not.
         * If renderRotation is false then the object can still rotate but it will never be rendered rotated.
         * @type {bool}
         */
        public renderRotation: bool = true;

        /**
         * The direction the animation frame is facing (can be Phaser.Types.RIGHT, LEFT, UP, DOWN).
         * Very useful when hooking animation to Sprite directions.
         */
        public facing: number;

        /**
         * Flip the graphic horizontally (defaults to false)
         * @type {bool}
         */
        public flippedX: bool = false;

        /**
         * Flip the graphic vertically (defaults to false)
         * @type {bool}
         */
        public flippedY: bool = false;

        /**
         * Is the texture a DynamicTexture?
         * @type {bool}
         */
        public isDynamic: bool = false;

        /**
         * The crop rectangle allows you to control which part of the sprite texture is rendered without distorting it.
         * Set to null to disable, set to a Phaser.Rectangle object to control the region that will be rendered, anything outside the rectangle is ignored.
         * @type {Phaser.Rectangle}
         */
        public crop: Phaser.Rectangle;

        /**
        * Hides an object from this Camera. Hidden objects are not rendered.
        *
        * @param object {Camera} The camera this object should ignore.
        */
        public hideFromCamera(camera: Phaser.Camera) {

            if (this.isHidden(camera) == false)
            {
                this.cameraBlacklist.push(camera.ID);
                this._blacklist++;
            }

        }

        /**
         * Returns true if this texture is hidden from rendering to the given camera, otherwise false.
         */
        public isHidden(camera: Phaser.Camera): bool {

            if (this._blacklist && this.cameraBlacklist.indexOf(camera.ID) !== -1)
            {
                return true;
            }

            return false;

        }

        /**
        * Un-hides an object previously hidden to this Camera.
        * The object must implement a public cameraBlacklist property.
        *
        * @param object {Sprite/Group} The object this camera should display.
        */
        public showToCamera(camera: Phaser.Camera) {

            if (this.isHidden(camera))
            {
                this.cameraBlacklist.slice(this.cameraBlacklist.indexOf(camera.ID), 1);
                this._blacklist--;
            }

        }

        /**
         * Updates the texture being used to render the Sprite.
         * Called automatically by SpriteUtils.loadTexture and SpriteUtils.loadDynamicTexture.
         */
        public setTo(image = null, dynamic: Phaser.Display.DynamicTexture = null) {

            if (dynamic)
            {
                this.isDynamic = true;
                this.dynamicTexture = dynamic;
                this.texture = this.dynamicTexture.canvas;
            }
            else
            {
                this.isDynamic = false;
                this.imageTexture = image;
                this.texture = this.imageTexture;
                this._width = image.width;
                this._height = image.height;
            }

            this.loaded = true;

            return this.parent;

        }

        /**
         * Sets a new graphic from the game cache to use as the texture for this Sprite.
         * The graphic can be SpriteSheet or Texture Atlas. If you need to use a DynamicTexture see loadDynamicTexture.
         * @param key {string} Key of the graphic you want to load for this sprite.
         * @param clearAnimations {bool} If this Sprite has a set of animation data already loaded you can choose to keep or clear it with this bool
         * @param updateBody {bool} Update the physics body dimensions to match the newly loaded texture/frame?
         */
        public loadImage(key: string, clearAnimations: bool = true, updateBody: bool = true) {

            if (clearAnimations && this.parent['animations'] && this.parent['animations'].frameData !== null)
            {
                this.parent.animations.destroy();
            }

            if (this.game.cache.getImage(key) !== null)
            {
                this.setTo(this.game.cache.getImage(key), null);
                this.cacheKey = key;

                if (this.game.cache.isSpriteSheet(key) && this.parent['animations'])
                {
                    this.parent.animations.loadFrameData(this.parent.game.cache.getFrameData(key));
                }
                else
                {
                    if (updateBody && this.parent['body'])
                    {
                        this.parent.body.bounds.width = this.width;
                        this.parent.body.bounds.height = this.height;
                    }
                }
            }

        }

        /**
         * Load a DynamicTexture as its texture.
         * @param texture {DynamicTexture} The texture object to be used by this sprite.
         */
        public loadDynamicTexture(texture: DynamicTexture) {

            if (this.parent.animations.frameData !== null)
            {
                this.parent.animations.destroy();
            }

            this.setTo(null, texture);
            this.parent.texture.width = this.width;
            this.parent.texture.height = this.height;

        }

        public set width(value: number) {
            this._width = value;
        }

        public set height(value: number) {
            this._height = value;
        }

        /**
         * The width of the texture. If an animation it will be the frame width, not the width of the sprite sheet.
         * If using a DynamicTexture it will be the width of the dynamic texture itself.
         * @type {number}
         */
        public get width(): number {

            if (this.isDynamic)
            {
                return this.dynamicTexture.width;
            }
            else
            {
                return this._width;
            }
        }

        /**
         * The height of the texture. If an animation it will be the frame height, not the height of the sprite sheet.
         * If using a DynamicTexture it will be the height of the dynamic texture itself.
         * @type {number}
         */
        public get height(): number {

            if (this.isDynamic)
            {
                return this.dynamicTexture.height;
            }
            else
            {
                return this._height;
            }

        }

    }

}