public class EncounterSession : IEncounterTransitionHandler
    {
        // Dependencies
        public IResourceGenerator ResourceGeneratorExtension { get; set; }

        // Privates
        private TransitioningStateNavigator navigator;
        private TransitioningGraph encounterStateGraph;

        // Properties

        private readonly Encounter _encounter;
        public Encounter Encounter
        {
            get { return _encounter; }
        }

        private readonly IList<Supply> _supplies;
        public IList<Supply> Supplies
        {
            get { return _supplies; }
        }

        private IReadOnlyCollection<Resource> _resources;
        public IReadOnlyCollection<Resource> Resources
        {
            get { return _resources; }
            private set { _resources = value; }
        }

        private IList<Task> _resolvedTasks;
        public IList<Task> ResolvedTasks
        {
            get { return _resolvedTasks; }
        }

        // Meta - Properties
        public IEnumerable<Task> RemainingTasks
        {
            get { return Encounter.Tasks.Except(ResolvedTasks); }
        }

        public string CurrentState
        {
            get
            {
                return navigator.CurrentState.ToString();
            }
        }

        public EncounterSession(Encounter encounter, IList<Supply> supplies)
            : base()
        {
            _encounter = encounter;
            _supplies = supplies;

            _resolvedTasks = new List<Task>();

            encounterStateGraph = new EncounterGraph(this);
            navigator = new TransitioningStateNavigator(encounterStateGraph);
        }

        protected EncounterSession()
        {
            _resolvedTasks = new List<Task>();
        }

        public bool RollAllowed(State beginState, State endState)
        {
            return (Supplies.Count == 0 || !ResolvedTasks.OrderBy(t => t).SequenceEqual(Encounter.Tasks.OrderBy(t => t)));
        }

        public void Roll()
        {
            Contract.Requires(ResourceGeneratorExtension != null);

            Resources = ResourceGeneratorExtension.GenerateResourcesFromSupplySet(Supplies);
            foreach (Resource r in Resources)
                Debug.WriteLine(r.ToString());
        }

        public bool AnyTaskCanBeResolved(State beginState, State endState)
        {
            return RemainingTasks.Any(t => TaskCanBeResolved(t));
        }

        public void ResolveTask()
        {
            throw new NotImplementedException();
        }

        public bool DiscardAllowed(State beginState, State endState)
        {
            throw new NotImplementedException();
        }

        public void ResolveDiscard()
        {
            throw new NotImplementedException();
        }

        public bool EncounterEligableForCompletion(State beginState, State endState)
        {
            throw new NotImplementedException();
        }

        public void CompleteEncounter()
        {
            throw new NotImplementedException();
        }

        public bool FailureIsEnsured(State beginState, State endState)
        {
            throw new NotImplementedException();
        }

        public void FailEncounter()
        {
            throw new NotImplementedException();
        }

        public bool EncounterOutcomeIsSatisfied(State beginState, State endState)
        {
            throw new NotImplementedException();
        }

        public void CleanupEncounter()
        {
            throw new NotImplementedException();
        }

        private bool TaskCanBeResolved(Task t)
        {
            IEnumerable<Glyph> requirements = t.Objectives.Cast<Glyph>().OrderBy(k => k.Name);
            IEnumerable<Glyph> candidates = Resources.Cast<Glyph>().OrderBy(k => k.Name);

            IEnumerable<Glyph> zeroCountCandidates = candidates.Where(c => c.Count == 0);
            IEnumerable<Glyph> zeroCountRequirements = requirements.Where(r => r.Count == 0);

            List<Glyph> remainingCandidates = zeroCountCandidates.ToList();

            if (zeroCountCandidates.Count() < zeroCountRequirements.Count())
            {
                return false;
            }

            foreach (var r in zeroCountRequirements)
            {
                if (!remainingCandidates.Contains(r))
                {
                    return false;
                }
                else
                {
                    remainingCandidates.Remove(r);
                }
            }

            IEnumerable<Glyph> nonZeroCountCandidates = candidates.Where(c => c.Count > 0);
            IEnumerable<Glyph> nonZeroCountRequirements = requirements.Where(r => r.Count > 0);

            var perms = nonZeroCountCandidates.Permutations();

            foreach (var perm in perms)
            {
                bool isViableSolution = true;

                remainingCandidates = perm.ToList();

                foreach (var requirement in nonZeroCountRequirements)
                {
                    int countThreshold = requirement.Count;
                    while (countThreshold > 0)
                    {
                        if (remainingCandidates.Count() == 0)
                        {
                            isViableSolution = false;
                            break;
                        }

                        var c = remainingCandidates[0];
                        countThreshold -= c.Count;

                        remainingCandidates.Remove(c);
                    }
                }

                if (isViableSolution)
                {
                    return true;
                }
            }

            return false;
        }


    }


 public class EncounterGraph : TransitioningGraph
    {
        private static State preRoll;
        private static State rolled;
        private static State taskResolved;
        private static State discarded;
        private static State resolved;
        private static State failed;
        private static State completed;

        static EncounterGraph()
        {
            preRoll = new State("Waiting for roll");
            rolled = new State("Rolled");
            taskResolved = new State("Task completed");
            discarded = new State("Discarded");
            resolved = new State("Encounter resolved");
            failed = new State("Encounter failed");
            completed = new State("Encounter completed");
        }


        public EncounterGraph(IEncounterTransitionHandler handler)
            : base(
            states: new State[]
                {
                    preRoll,
                    rolled,
                    taskResolved,
                    discarded,
                    resolved,
                    failed,
                    completed
                },
            edges: new TransitionEdge[]
                {
                    new TransitionEdge(
                        beginState:    preRoll,
                        endState:      rolled,
                        canTransition: handler.RollAllowed,
                        transition:    handler.Roll ),
                    new TransitionEdge(
                        beginState:    rolled,
                        endState:      taskResolved,
                        canTransition: handler.AnyTaskCanBeResolved,
                        transition:    handler.ResolveTask),
                    new TransitionEdge(
                        beginState:    rolled,
                        endState:      discarded,
                        canTransition: handler.DiscardAllowed,
                        transition:    handler.ResolveDiscard),
                    new TransitionEdge(
                        beginState:    taskResolved,
                        endState:      resolved,
                        canTransition: handler.EncounterEligableForCompletion,
                        transition:    handler.CompleteEncounter),
                    new TransitionEdge(
                        beginState:    discarded,
                        endState:      failed,
                        canTransition: handler.FailureIsEnsured,
                        transition:    handler.FailEncounter),
                    new TransitionEdge(
                        beginState:    taskResolved,
                        endState:      rolled,
                        canTransition: handler.RollAllowed,
                        transition:    handler.Roll),
                    new TransitionEdge(
                        beginState:    discarded,
                        endState:      rolled,
                        canTransition: handler.RollAllowed,
                        transition:    handler.Roll),
                    new TransitionEdge(
                        beginState:    resolved,
                        endState:      completed,
                        canTransition: handler.EncounterOutcomeIsSatisfied,
                        transition:    handler.CleanupEncounter),
                    new TransitionEdge(
                        beginState:    failed,
                        endState:      completed,
                        canTransition: handler.EncounterOutcomeIsSatisfied,
                        transition:    handler.CleanupEncounter),
                },
            start: preRoll) { }
    }


    public interface IEncounterTransitionHandler
    {
        bool RollAllowed(State beginState, State endState);
        void Roll();

        bool AnyTaskCanBeResolved(State beginState, State endState);
        void ResolveTask();

        bool DiscardAllowed(State beginState, State endState);
        void ResolveDiscard();

        bool EncounterEligableForCompletion(State beginState, State endState);
        void CompleteEncounter();

        bool FailureIsEnsured(State beginState, State endState);
        void FailEncounter();

        bool EncounterOutcomeIsSatisfied(State beginState, State endState);
        void CleanupEncounter();
    }