"""
In search.py, you will implement generic search algorithms which are called by
Pacman agents (in searchAgents.py).

Please only change the parts of the file you are asked to.  Look for the lines
that say
"*** YOUR CODE HERE ***"

Follow the project description for details.

Good luck and happy searching!
"""

import util

class SearchProblem:
    """
    This class outlines the structure of a search problem, but doesn't implement
    any of the methods (in object-oriented terminology: an abstract class).

    You do not need to change anything in this class, ever.
    """

    def getStartState(self):
        """
        Returns the start state for the search problem.
        """
        util.raiseNotDefined()

    def isGoalState(self, state):
        """
          state: Search state

        Returns True if and only if the state is a valid goal state.
        """
        util.raiseNotDefined()

    def getSuccessors(self, state):
        """
          state: Search state

        For a given state, this should return a list of triples, (successor,
        action, stepCost), where 'successor' is a successor to the current
        state, 'action' is the action required to get there, and 'stepCost' is
        the incremental cost of expanding to that successor.
        """
        util.raiseNotDefined()

    def getCostOfActions(self, actions):
        """
         actions: A list of actions to take

        This method returns the total cost of a particular sequence of actions.
        The sequence must be composed of legal moves.
        """
        util.raiseNotDefined()

def tinyMazeSearch(problem):
    """
    Returns a sequence of moves that solves tinyMaze.  For any other maze, the
    sequence of moves will be incorrect, so only use this for tinyMaze.
    """
    from game import Directions
    s = Directions.SOUTH
    w = Directions.WEST
    return  [s, s, w, s, w, w, s, w]

def depthFirstSearch(problem: SearchProblem):
    """
    Search the deepest nodes in the search tree first.

    Your search algorithm needs to return a list of actions that reaches the
    goal. Make sure to implement a graph search algorithm.

    To get started, you might want to try some of these simple commands to
    understand the search problem that is being passed in:

    print("Start:", problem.getStartState())
    print("Is the start a goal?", problem.isGoalState(problem.getStartState()))
    print("Start's successors:", problem.getSuccessors(problem.getStartState()))
    """
    "*** YOUR CODE HERE ***"

    path = []

    curr_state = problem.getStartState()            # (5, 5)
    isGoal = problem.isGoalState(curr_state)

    visited = list()
    stack = util.Stack()
    stack.push(((curr_state, 'None', 0), path))                  # (state, path)

    while not isGoal:
        if stack.isEmpty():
            return []
        else:
            ((new_state, direction, cost), path) = stack.pop()                     # ((location, direction, cost), path)
            if new_state in visited:
                continue
            path = path + [direction]
            visited.append(new_state)
            isGoal = problem.isGoalState(new_state)
            if isGoal:
                break
            for (_state, _direction, _cost) in problem.getSuccessors(new_state):                  # (state, direction, cost)
                stack.push(((_state, _direction, _cost), path))
    path = path[1:]

    return path
            


def breadthFirstSearch(problem: SearchProblem):
    """Search the shallowest nodes in the search tree first."""
    "*** YOUR CODE HERE ***"
    path = []

    curr_state = problem.getStartState()            # (5, 5)
    isGoal = problem.isGoalState(curr_state)

    visited = list()
    queue = util.Queue()
    queue.push(((curr_state, 'None', 0), path))                  # (state, path)

    while not isGoal:
        if queue.isEmpty():
            return []
        else:
            ((new_state, direction, cost), path) = queue.pop()                     # ((location, direction, cost), path)
            if new_state in visited:
                continue
            path = path + [direction]
            visited.append(new_state)
            isGoal = problem.isGoalState(new_state)
            if isGoal:
                break
            for (_state, _direction, _cost) in problem.getSuccessors(new_state):                  # (state, direction, cost)
                queue.push(((_state, _direction, _cost), path))
    path = path[1:]

    return path
    

def uniformCostSearch(problem: SearchProblem):
    """Search the node of least total cost first."""
    "*** YOUR CODE HERE ***"
    path = []
    costs = 0

    curr_state = problem.getStartState()            # (5, 5)
    isGoal = problem.isGoalState(curr_state)

    visited = list()
    queue = util.PriorityQueue()
    queue.push(((curr_state, 'None', 0), path, costs), 0)                  # (state, path)

    while not isGoal:
        if queue.isEmpty():
            return []
        else:
            ((new_state, direction, cost), path, costs) = queue.pop()                     # ((location, direction, cost), path)
            if new_state in visited:
                continue
            path = path + [direction]
            costs = costs + cost
            visited.append(new_state)
            isGoal = problem.isGoalState(new_state)
            if isGoal:
                break
            for (_state, _direction, _cost) in problem.getSuccessors(new_state):                  # (state, direction, cost)
                queue.push(((_state, _direction, _cost), path, costs), costs+_cost)
    path = path[1:]

    return path
    

def nullHeuristic(state, problem=None):
    """
    A heuristic function estimates the cost from the current state to the nearest
    goal in the provided SearchProblem.  This heuristic is trivial.
    """
    return 0

def aStarSearch(problem: SearchProblem, heuristic=nullHeuristic):
    """Search the node that has the lowest combined cost and heuristic first."""
    "*** YOUR CODE HERE ***"
    path = []
    costs = 0

    curr_state = problem.getStartState()            # (5, 5)
    isGoal = problem.isGoalState(curr_state)

    visited = list()
    queue = util.PriorityQueue()
    queue.push(((curr_state, 'None', 0), path, costs), 0)                  # (state, path)

    min_cost = {curr_state: 0}

    while not isGoal:
        if queue.isEmpty():
            return []
        else:
            ((new_state, direction, cost), path, costs) = queue.pop()                     # ((location, direction, cost), path)
            if new_state in visited and (costs+cost)>=min_cost[new_state]:
                continue
            path = path + [direction]
            costs = costs + cost
            min_cost[new_state] = costs
            visited.append(new_state)
            isGoal = problem.isGoalState(new_state)
            if isGoal:
                break
            for (_state, _direction, _cost) in problem.getSuccessors(new_state):                  # (state, direction, cost)
                queue.push(((_state, _direction, _cost), path, costs), costs+_cost+heuristic(_state, problem))
    path = path[1:]

    return path


# Abbreviations
bfs = breadthFirstSearch
dfs = depthFirstSearch
astar = aStarSearch
ucs = uniformCostSearch