use std::collections::HashMap;

use std::fmt;

use crate::PG;

use crate::Player;

use crate::Set;

use crate::VertexIndex;

/// A strategy abstraction used by Zielonka.

///

/// This allows running the solver with either full strategy construction

/// (`Strategy`) or with a zero-cost no-op strategy (`()`).

pub trait Strat: Sized {

    /// Creates a new empty strategy value.

    fn new() -> Self;

    /// Records a strategy move from `from` to `to`.

    fn set(&mut self, from: VertexIndex, to: VertexIndex);

    /// Gets the strategy move for `from`, if one is defined.

    fn get(&self, from: VertexIndex) -> Option<VertexIndex>;

    /// Removes any strategy move for `from`.

    fn remove(&mut self, from: VertexIndex);

    /// Combines two strategy values.

    fn union(self, other: Self) -> Self;

    /// Extends with arbitrary choices on unresolved owned vertices.

    fn extend_arbitrary<G: PG>(self, pg: &G, vertices: &Set, subgame: &Set, player: Player) -> Self;

}

/// Keeps track of a strategy for a player in a parity game.

///

/// # Details

///

/// A strategy is a partial function from vertices owned by a player to one of

/// their successors.

pub struct Strategy {

    mapping: HashMap<VertexIndex, VertexIndex>,

}

impl Strategy {

    /// Creates a new, empty strategy.

    /// Adds a mapping from `from` to `to` in the strategy.

    /// Gets the target vertex for the given source vertex, if it is defined.

    /// Removes the strategy entry for the given vertex, if it exists.

    /// Computes the union of two strategies, assumes that they do not overlap.

        // Add all mappings from the extension strategy to the base strategy

                "Cannot combine strategies with overlapping domains"

            );

        }

    /// Extends the strategy with an arbitrary strategy for the given `player` on the given `vertices`.

                // Add an arbitrary mapping for this vertex, we can just take the first outgoing edge.

        }

    /// Returns an iterator over all (from, to) pairs in the strategy.

    /// Checks that the strategy is only defined for the vertices owned by the

    /// given player. Furthermore, ensure that the strategy is defined for all

    /// vertices won in the solution for the given player

                    "Strategy is not defined for vertex {:?} owned by {:?}, but is in the winning set.",

                    vertex,

                );

                    "Strategy is defined for vertex {:?} owned by {:?}, but it should be owned by {:?}.",

                    vertex,

                    player

                );

        }

}

impl Strat for Strategy {

}

impl Strat for () {

}

impl Default for Strategy {

}

impl fmt::Debug for Strategy {

        }

}