/**
 * Represents the current state of a map
 *
 *  Copyright (C) 2012  Mike Gerwitz
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Affero General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Affero General Public License for more details.
 *
 *  You should have received a copy of the GNU Affero General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/**
 * Represents the current state of a map
 */
ltjs.MapState = Class( 'MapState',
{
    /**
     * Game object factory
     * @type {ltjs.GameObjectFactory}
     */
    'private _objFactory': null,

    /**
     * Player game object tile position
     * @type {number}
     */
    'private _playerPos': 0,

    /**
     * Reference to player object
     * @type {GameObject}
     */
    'private _player': null,

    /**
     * Game objects representing every object on the map
     * @type {GameObject}
     */
    'private _objs': [],

    /**
     * Continuations to invoke when object state changes
     * @type {Array.<function(GameObject,number)>}
     */
    'private _stateCallbacks': [],


    /**
     * Initializes map state with a given map and factory with which to create
     * game objects
     *
     * Game objects influence map state rules, therefore fundamental game logic
     * may be altered simply by passing in a custom GameObjectFactory instance.
     *
     * @param  {Map}                map          game map
     * @param  {GameObjectFactory}  obj_factory  game object factory
     */
    __construct: function( map, obj_factory )
    {
        if ( !( Class.isA( ltjs.GameObjectFactory, obj_factory ) ) )
        {
            throw TypeError( 'Invalid GameObjectFactory provided' );
        }

        // initialize game objects based on the initial map state
        this._objFactory = obj_factory;
        this._initObjects( map.getObjects(), map.getObjectTileMap() );
    },


    /**
     * Flush map state, triggering the change event for each game object
     *
     * This may be used to perform an initial rendering or re-draw of the entire
     * map. Note that this should not be used to re-render the map after
     * movements or state changes, as that would not be performant (especially
     * since the map size could be arbitrarily large).
     */
    'public flush': function()
    {
        var _self = this;

        // emit the change event for each game object
        this._forEachObj( function( obj, pos )
        {
            _self._emitChange( obj, pos );
        } );
    },


    /**
     * Register an object change callback
     *
     * Registers a continuation to be called when a game object changes state
     * (a state change may represent an object transforming into another, a
     * movement, or anything else that requires re-rendering).
     *
     * TODO: use event base
     *
     * The continuation will be passed the game object in its new state its tile
     * position. If the game object is null, then it is to be assumed that the
     * object no longer exists (e.g. has moved to another location) and should
     * be cleared.
     *
     * @param  {function(GameObject,number)}  callback  continuation
     *
     * @return  {MapState}  self
     */
    'public onChange': function( callback )
    {
        this._stateCallbacks.push( callback );
        return this;
    },


    /**
     * Emit a change event for the given object
     *
     * States that an object's state has changed; see the onChange() method for
     * additional information. A change may not necessarily imply that the
     * object itself has changed---the change may simply represent a new
     * position or---in the case of a null object---that the position has been
     * cleared of an object.
     *
     * @param  {GameObject}  obj  the game object that has updated, or null
     * @param  {number}      pos  tile position of the game object
     *
     * @return  {undefined}
     */
    'private _emitChange': function( obj, pos )
    {
        var i = -1,
            l = this._stateCallbacks.length;

        while ( ++i < l )
        {
            this._stateCallbacks[ i ].call( this.__inst, obj, pos );
        }

        if ( obj === null )
        {
            var _self = this;
            this._objs[ pos ].forEach( function( o )
            {
                if ( o === null ) return;

                _self._emitChange( o, pos );
            } );
        }
    },


    /**
     * Initialize game objects for the map's original (default) state
     *
     * All necessary game objects will be created to represent all objects on
     * the map at its default state. Effectively, this creates the default map
     * state.
     *
     * @param  {Array.<number>}  objs    game object data (object ids)
     * @param  {Array.<string>}  objmap  map from object ids to their tile ids
     *
     * @return  {undefined}
     */
    'private _initObjects': function( objs, objmap )
    {
        var i = objs.length;

        while ( i-- )
        {
            var val = objs[ i ],
                obj = this._createObj( objmap[ val ] );

            this._objs[ i ] = [];
            this._addObj( obj, i );

            // XXX: temporary
            if ( val === 1 )
            {
                this._initPlayer( obj, i );
            }
        }
    },


    /**
     * Creates a game object from a given tile id and (optionally) a previous
     * object
     *
     * A previous game object may be provided if state is to be transferred
     * between objects---that is, the transformation of one game object into
     * another may require a certain transfer of information. If no such game
     * object is provided, then the game object will be created with its default
     * state.
     *
     * @param  {string}       tid   tile id
     * @param  {GameObject?}  from  optional game object for state change data
     *
     * @return  {GameObject}  new game object
     */
    'private _createObj': function( tid, from )
    {
        var obj = this._objFactory.createObject( tid );

        // if a previous object was provided, copy over its mutable attributes
        if ( from )
        {
            from.cloneTo( obj );
        }

        return obj;
    },


    /**
     * Invokes a continuation for each game object on the map
     *
     * The continuation will be called with the game object and its tile
     * position.
     *
     * @param  {function(GameObject, number)}  c  continuation
     *
     * @return  {undefined}
     */
    'private _forEachObj': function( c )
    {
        this._objs.forEach( function( objs, pos )
        {
            objs.forEach( function( obj )
            {
                c( obj, pos );
            } );
        } );
    },


    /**
     * Add a game object at the given tile position
     *
     * It is an error to provide an invalid tile position or non-game object.
     *
     * @param  {GameObject}  obj  game object to add
     * @param  {number}      pos  tile position
     *
     * @return  {undefined}
     *
     * @throws  {Error}      if an invalid tile position
     * @throws  {TypeError}  if an invalid replacement game object
     */
    'private _addObj': function( obj, pos )
    {
        // replace no object with the given object (that is, replace nothing
        // with something---add)
        this._replaceObj( null, obj, pos );
    },


    /**
     * Replaces the given game object at the given tile position with a new game
     * object
     *
     * If the given game object can be found at the given tile position, then it
     * will be replaced with the new given game object. If it cannot be found,
     * then it will be added at the given tile position without any replacement
     * being made (effectively an append), unless the given replacement object
     * is null.
     *
     * If appending, the object will be placed in any open space (represented by
     * a null); ``open'' space is created when an object is replaced with null,
     * which has the effect of removing an object entirely (with no
     * replacement).
     *
     * The change will result in the notification of any observers that have
     * registered continuations for game object state changes.
     *
     * It is an error to provide an unknown tile position or a replacement that
     * is not a game object.
     *
     * @param  {GameObject}  cur     game object to replace (or null)
     * @param  {GameObject}  newobj  replacement game object
     * @param  {number}      pos     tile position
     *
     * @return  {undefined}
     *
     * @throws  {Error}      if an invalid tile position
     * @throws  {TypeError}  if an invalid replacement game object
     */
    'private _replaceObj': function( cur, newobj, pos )
    {
        var o = this._objs[ pos ],
            i = o.length;

        // type checks
        if ( !( Array.isArray( o ) ) )
        {
            throw Error( "Invalid tile position: " + pos );
        }
        if ( !( Class.isA( ltjs.gameobjs.GameObject, newobj )
            || ( newobj === null )
        ) )
        {
            throw TypeError( "Invalid GameObject or null provided: " + newobj );
        }

        var free = null;

        ( function()
        {
            while ( i-- )
            {
                if ( o[ i ] === cur )
                {
                    o[ i ] = newobj;
                    return;
                }
                else if ( o[ i ] === null )
                {
                    // record this as a free position for additions
                    free = i;
                }
            }

            // not found; add
            if ( newobj === null ) return;
            else if ( free )       o[ i ] = newobj;
            else                   o.push( newobj );
        } )();

        // notify observers of the change
        this._emitChange( newobj, pos );
    },


    /**
     * Remove a game object at the given tile position
     *
     * If the game object is not found at the given tile position, then no
     * action will be taken.
     *
     * It is an error to provide an invalid tile position.
     *
     * @param  {GameObject}  obj  game object to remove
     * @param  {number}      pos  tile position
     *
     * @return  {undefined}
     *
     * @throws  {Error}  if an invalid tile position
     */
    'private _removeObj': function( obj, pos )
    {
        this._replaceObj( obj, null, pos );
    },


    /**
     * Move a game object from one tile position to another
     *
     * This has the direct effect of (a) removing the given game object from its
     * original position and (b) adding it to its new position.
     *
     * It is an error to specify an object that is not a game object, or to
     * specify tile positions that do not exist.
     *
     * @param  {GameObject}  obj   game object to move
     * @param  {number}      from  original tile position
     * @param  {number}      to    destination tile position
     *
     * @return  {undefined}
     *
     * @throws  {TypeError}  if an invalid game object
     * @throws  {Error}      if an invalid tile position
     */
    'private _moveObj': function( obj, from, to )
    {
        this._removeObj( obj, from );
        this._addObj( obj, to );
    },


    /**
     * Initializes player game object and tile position references
     *
     * These references exist purely for performance, preventing the need to
     * scan for game objects that may represent the player. This also allows for
     * any arbitrary game object to represent the "player".
     *
     * @param  {GameObject}  obj  game object representing the player
     * @param  {number}      pos  player tile position
     */
    'private _initPlayer': function( obj, pos )
    {
        this._player    = obj;
        this._playerPos = pos;
    },


    /**
     * Changes the state of a game object at a given tile position
     *
     * The "state" of a game object is represented by the object's type. If the
     * state is unchanged, then no action will be taken. Otherwise, the game
     * object at the given tile position, if available, will be replaced with a
     * new game object representing the given state. If a game object cannot be
     * found at the given tile position, then it will be added.
     *
     * @param  {GameObject}  cur    current game object
     * @param  {string}      state  new object state
     * @param  {number}      pos    tile position
     *
     * @return  {GameObject}  new game object
     *
     * @throws  {TypeError}  if state results in an invalid game object
     * @throws  {Error}      if an invalid tile position
     */
    'private _changeState': function( cur, state, pos )
    {
        // if the state has not changed, then do nothing
        if ( state === cur.getTid() )
        {
            return;
        }

        // replace game object with a new one
        var newobj = this._createObj( state, cur );
        this._replaceObj( cur, newobj, pos );

        return newobj;
    },


    /**
     * Creates a callback to alter the state of an object
     *
     * Produces a continuation that will perform a state change on the given
     * game object. The desired state should be passed to the continuation.
     *
     * If an additional continuation c is provided, it will be invoked after the
     * state change and may be used to process the resulting game object.
     *
     * @param  {GameObject}  cur  game object to alter
     * @param  {number}      pos  game object tile position
     *
     * @param  {function(GameObject)=}  c  additional continuation
     *
     * @return  {function(string)}  callback to perform state change
     */
    'private _createStateCallback': function( cur, pos, c )
    {
        var _self = this;

        return function( state )
        {
            var newobj = _self._changeState( cur, state, pos );

            if ( typeof c === 'function' )
            {
                c( newobj );
            }
        };
    },


    /**
     * Creates a callback to move a game object to a new tile position
     *
     * Produces a continuation that will perform a tile position move on the
     * given game object. The desired direction of movement should be passed to
     * the continuation (see MapAction for direction codes).
     *
     * If an additional continuation c is provided, it will be invoked after the
     * movement and may be used to process the new position.
     *
     * @param  {GameObject}  cur  game object to alter
     * @param  {number}      pos  game object tile position
     *
     * @param  {function(GameObject)=}  c  additional continuation
     *
     * @return  {function(string)}  callback to perform state change
     */
    'private _createMoveCallback': function( obj, pos, c )
    {
        var _self = this;

        return function( dest )
        {
            _self._moveObj( obj, pos, dest );

            // call continuation with new position, if requested
            if ( typeof c === 'function' )
            {
                c( dest );
            }
        };
    },


    /**
     * Move a player in the given direction
     *
     * The directions, as defined in MapAction, are: 0:left, 1:up, 2:right,
     * 3:down.
     *
     * XXX: the bounds argument is temporary
     *
     * @param  {number}     direction  direction code
     * @param  {MapBounds}  bounds     map boundaries
     *
     * @return  {undefined}
     */
    'public movePlayer': function( direction, bounds )
    {
        var _self  = this,
            player = this._player;

        // XXX: tightly coupled
        var action = ltjs.MapAction(
            bounds,
            this._createMoveCallback( player, this._playerPos, function( pos )
            {
                _self._playerPos = pos;
            } )
        );

        var sc = this._createStateCallback( player, this._playerPos, function( o )
        {
            _self._player = o;
        } );

        action.direction = direction;
        action.srcPos    = this._playerPos;
        player.move( direction, function()
        {
            action.move();
        }, sc );
    }
} );