/*
 * Outpost.cs
 * Authors: Bradley R. Blankenship
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 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 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework;

namespace ColonySim.Structures
{
    /// <summary>
    /// Represents an outpost in outer space. Outposts can be used to harvest
    /// resources from nearby Resource Containers, transport resources via
    /// connected Tubes, etc.
    /// </summary>
    class Outpost : Structure
    {
        #region Fields

        // The array of connection tubes this can have
        List<Tube> mConnections;

        // The input resource
        Resource mInputResource;

        // The output resource
        Resource mOutputResource;

        // The temp storage this has for resources
        int mStorage;

        #endregion

        #region Properties

        /// <summary>
        /// Allows access to the connections this Outpost has.
        /// </summary>
        public List<Tube> Connections
        {
            get { return mConnections; }
        }

        /// <summary>
        /// Allows access to the input resource.
        /// </summary>
        public Resource InputResource
        {
            get { return mInputResource; }
            set { mInputResource = value; }
        }

        /// <summary>
        /// Allows access to the output resource.
        /// </summary>
        public Resource OutputResource
        {
            get { return mOutputResource; }
            set { mOutputResource = value; }
        }

        #endregion
        
        #region Constructs

        /// <summary>
        /// Create the given structure.
        /// </summary>
        /// <param name="pContent">The content manager</param>
        /// <param name="pModelName">The name of our model</param>
        /// <param name="pTextureName">The name of our texture</param>
        public Outpost(ContentManager pContent, string pModelName,
            string pTextureName) : base(pContent,pModelName,pTextureName)
        {
            // Create our list
            mConnections = new List<Tube>();
        }

        #endregion

        #region Behavior

        /// <summary>
        /// Process the current turn.
        /// </summary>
        public override void Tick()
        {
            // Process our current resources
            ProcessResources();
        }

        /// <summary>
        /// Receive the given carrier.
        /// </summary>
        /// <param name="pCarrier">The current carrier.</param>
        /// <returns>Whether we received it or not.</returns>
        public override bool ReceiveCarrier(Carrier pCarrier)
        {
            // Make the carrier halt
            pCarrier.Direction = Carrier.Directions.None;

            // The return value
            bool retVal = false;

            // If the resource it has is the same as ours
            if (InputResource!= null && pCarrier.Resource.ResourceCode == InputResource.ResourceCode)
            {
                // Store the value
                mStorage += pCarrier.Resource.Amount;

                // Now set the retval to be true
                retVal = true;
            }

            // Report back the gains of the carrier
            GridReference.StatusInfo.Money += pCarrier.Value;

            // Dispose of the Carrier
            pCarrier.Dispose();

            // Return true as the base is
            return retVal;
        }

        /// <summary>
        /// Processes the resources that this Outpost has.
        /// </summary>
        private void ProcessResources()
        {
            // If we have enough resources in storage or don't require an input
            if (mInputResource == null || mInputResource.Amount < mStorage)
            {
                // Then, if we have a production item
                if (mOutputResource != null && mConnections.Count > 0)
                {
                    // The output tubes
                    List<Tube> outputs = new List<Tube>();

                    // Get the output tubes
                    foreach (Tube tube in mConnections)
                    {
                        // See if it is facing the right way to be an output tube, and it's not null
                        if ((tube.GridPosition.X < this.GridPosition.X && tube.Running == Tube.Runnings.Negative_X) ||
                            (tube.GridPosition.X > this.GridPosition.X && tube.Running == Tube.Runnings.Positive_X) ||
                            (tube.GridPosition.Y < this.GridPosition.Y && tube.Running == Tube.Runnings.Negative_Y) ||
                            (tube.GridPosition.Y > this.GridPosition.Y && tube.Running == Tube.Runnings.Positive_Y))
                        {
                            // Add the tube
                            outputs.Add(tube);
                        }
                    }

                    // See if we have any output tubes
                    if (outputs.Count > 0)
                    {
                        // Set the value appropriately
                        Resource output = mOutputResource.Clone();
                        output.Amount /= outputs.Count;

                        // Now for each of the connections, do the following
                        foreach (Tube tube in outputs)
                        {
                            // Output the given resource, with a new carrier
                            Carrier carrier = new Carrier(
                                this.Content, @"Models\TestCarrier", @"Textures\BluePixel");
                            carrier.Resource = output.Clone();
                            carrier.TransformationMatrix = Matrix.CreateTranslation(
                                tube.TransformationMatrix.Translation);
                            carrier.GridPosition = tube.GridPosition;
                            carrier.DrawOrder = tube.DrawOrder - 1;

                            // Tell the tube to receive the connection
                            tube.ReceiveCarrier(carrier);

                            // Add the carrier to the grid
                            GridReference.AddCarrier(carrier);
                        }
                    }
                }

                // If we have an input resource
                if (mInputResource != null)
                {
                    // Consume resources from the storage
                    mStorage -= mInputResource.Amount;
                }
            }
        }

        #endregion

        #region Utility

        /// <summary>
        /// Returns a clone of this structure.
        /// </summary>
        /// <returns>The cloned structure.</returns>
        public override Structure Clone()
        {
            // Create the return value
            Outpost retVal = new Outpost(this.Content, this.ModelPath, this.TexturePath);

            // Set the values to ours
            retVal.Name = this.Name;
            retVal.FootPrintSize = this.FootPrintSize;
            retVal.Cost = this.Cost;
            retVal.DrawOrder = this.DrawOrder;
            retVal.TechniqueName = this.TechniqueName;

            // If we have an input resource
            if (mInputResource != null)
            {
                // Copy the input resource
                retVal.InputResource = this.InputResource.Clone();
            }

            // If we have an output resource
            if (mOutputResource != null)
            {
                // Copy the output resource
                retVal.OutputResource = this.OutputResource.Clone();
            }

            // Return the retval
            return retVal;
        }

        #endregion
    }
}