/*
 * Factory.cs
 * Authors:     August Zinsser
 * 
 * Copyright Matthew Belmonte 2007
 */


using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
using tAC_Engine;
using Pina3D;


namespace Astropolis.ColonySimulator
{
    /// <summary>
    /// A structure that (optinally) inputs commodities and outputs other commodities.
    /// </summary>
    public class Factory : Building
    {
        public override Dictionary<string, int> InputInventory { get { return ((FactoryState)mState).InputInventory; } }
        public override Dictionary<string, int> OutputInventory { get { return ((FactoryState)mState).OutputInventory; } }
        /// <summary>
        /// Returns true if production has stopped because there is no more room to store its products
        /// </summary>
        public bool IsOutputInventoryFull { get { return !HaveEnoughSpace(); } }



        /// <summary>
        /// Create a new Building
        /// </summary>
        public Factory(FactoryType type, StructureState state)
        {
            mType = type;
            mState = new FactoryState(state);
            Pina.AddRenderable(type.Model);

            // Flesh out the inventories
            foreach (KeyValuePair<string, int> kvp in ((FactoryType)mType).Inputs)
            {
                ((FactoryState)mState).InputInventory.Add(kvp.Key, 0);
            }
            foreach (KeyValuePair<string, int> kvp in ((FactoryType)mType).Outputs)
            {
                ((FactoryState)mState).OutputInventory.Add(kvp.Key, 0);
            }
        }


        /// <summary>
        /// Attempts to add some quantity of a commodity to this building's input inventory
        /// </summary>
        /// <returns>True if successfully added, false otherwise</returns>
        public override bool Deliver(string commodity, int quantity)
        {
            // Must be enough space in the input inventory
            if (((FactoryState)mState).InputInventory.ContainsKey(commodity) &&
                ((FactoryState)mState).InputInventory[commodity] + quantity <= ((FactoryType)mType).Inputs[commodity] * ((FactoryType)mType).InventorySize)
            {
                ((FactoryState)mState).InputInventory[commodity] += quantity;
                return true;
            }

            return false;
        }


        /// <summary>
        /// Attempts to subtract the specified quantity of the specified commodity from this building's output inventory
        /// </summary>
        /// <returns>True if successfully removed, false otherwise</returns>
        public override bool Ship(string commodity, int quantity)
        {
            if (((FactoryState)mState).OutputInventory.ContainsKey(commodity) &&
                ((FactoryState)mState).OutputInventory[commodity] >= quantity)
            {
                ((FactoryState)mState).OutputInventory[commodity] -= quantity;
                return true;
            }

            return false;
        }


        /// <summary>
        /// Return true if there is enough space in the internal output inventory to store products
        /// </summary>
        /// <returns></returns>
        protected bool HaveEnoughSpace()
        {
            foreach (KeyValuePair<string, int> kvp in ((FactoryType)mType).Outputs)
            {
                if ((((FactoryState)mState).OutputInventory[kvp.Key] + ((FactoryType)mType).Outputs[kvp.Key]) >
                    (((FactoryType)mType).Outputs[kvp.Key] * ((FactoryType)mType).InventorySize))
                    return false;
            }

            return true;
        }


        /// <summary>
        /// Current quantity / max capacity
        /// </summary>
        /// <returns>0 if the building does not store the given commodity</returns>
        public float PercentageOutputInventory(string commodity)
        {
            if (!((FactoryState)mState).OutputInventory.ContainsKey(commodity))
                return 0;

            return (float)((FactoryState)mState).OutputInventory[commodity] /
                ((float)(((FactoryType)mType).Outputs[commodity] * ((FactoryType)mType).InventorySize));
        }


        /// <summary>
        /// Current quantity / max capacity
        /// </summary>
        /// <returns>0 if the building does not store the given commodity</returns>
        public float PercentageInputInventory(string commodity)
        {
            if (!((FactoryState)mState).InputInventory.ContainsKey(commodity))
                return 0;

            return (float)((FactoryState)mState).InputInventory[commodity] /
                ((float)(((FactoryType)mType).Inputs[commodity] * ((FactoryType)mType).InventorySize));
        }


        /// <summary>
        /// Produces if possible
        /// </summary>
        /// <param name="dT"></param>
        public override void Update(float dT)
        {
            base.Update(dT);

            ((FactoryState)mState).ProductionTimer -= dT;


            // Produce as many times as possible
            bool haveEnoughInputs = true;
            bool haveEnoughSpace = true;
            bool enoughTimeHasPassed = true;
            while (haveEnoughInputs && haveEnoughSpace && enoughTimeHasPassed)
            {
                // Check inventory
                foreach (KeyValuePair<string, int> kvp in ((FactoryType)mType).Inputs)
                {
                    if (((FactoryState)mState).InputInventory[kvp.Key] < kvp.Value)
                        haveEnoughInputs = false;
                }
                haveEnoughSpace = HaveEnoughSpace();

                // See if enough time has passed to make another one
                if (((FactoryState)mState).ProductionTimer > 0)
                    enoughTimeHasPassed = false;

                // Produce
                if (haveEnoughInputs && haveEnoughSpace && enoughTimeHasPassed)
                {
                    // Remove inputs
                    foreach (KeyValuePair<string, int> kvp in ((FactoryType)mType).Inputs)
                    {
                        ((FactoryState)mState).InputInventory[kvp.Key] -= kvp.Value;
                    }

                    // Create outputs
                    foreach (KeyValuePair<string, int> kvp in ((FactoryType)mType).Outputs)
                    {
                        ((FactoryState)mState).OutputInventory[kvp.Key] += kvp.Value;
                    }

                    // Account for the production time spent
                    ((FactoryState)mState).ProductionTimer += ((FactoryType)mType).ProductionTime;
                }
            }

            // If the building is not currently producing something, then reset the production timer
            if (!haveEnoughInputs || !haveEnoughSpace)
                ((FactoryState)mState).ProductionTimer = ((FactoryType)mType).ProductionTime;
        }


        protected class FactoryState : StructureState
        {
            /// <summary>
            /// The commodities this building must accumulate before producing outputs
            /// </summary>
            public Dictionary<string, int> InputInventory = new Dictionary<string, int>();
            /// <summary>
            /// The commodities this building produces once all inputs have been satisfied and enough time has passed
            /// </summary>
            public Dictionary<string, int> OutputInventory = new Dictionary<string, int>();
            /// <summary>
            /// Counts down the time remaining to produce an output
            /// </summary>
            public float ProductionTimer = 0f;


            public FactoryState(StructureState state)
                : base(state.Matrix, state.BoundingBox)
            {
            }
        }
    }


    public class FactoryType : BuildingType
    {
        /// <summary>
        /// Number of gamedays it takes to produce outputs (once all inputs are received)
        /// </summary>
        public float ProductionTime;
        /// <summary>
        /// The size of a Factory's internal input/output inventory relative to BuildingType's input/output quantity
        /// </summary>
        public float InventorySize = 2f;


        public FactoryType(
            PinaModel model,
            int footprintWidth,
            int footprintHeight,
            Dictionary<string, int> inputs,
            Dictionary<string, int> outputs,
            float productionTime)
            : base(model, footprintWidth, footprintHeight, inputs, outputs)
        {
            this.ProductionTime = productionTime;
        }
    }
}