import re,sys

def toGrid(input,parser=None):
    grid = []
    if parser:
        with open(input) as file:
            for line in file:
                grid.append(list2int(line.rstrip()))
    else:
        with open(input) as file:
            for line in file:
                grid.append(list(line.rstrip()))
    return grid


def findDupes(input:list):
    # Returns the indicies of duplicate values in list
    return [item for item in set(input) if input.count(item) > 1]

def lprint(x:str,log:bool):
    if log:
        print(x)

def expand_grid(grid):
    num_rows = len(grid)
    num_cols = len(grid[0])

    expanded_grid = []

    expanded_grid.append(['.'] * (num_cols + 2))

    for row in grid:
        expanded_grid.append(['.'] + row + ['.'])

    expanded_grid.append(['.'] * (num_cols + 2))

    return expanded_grid

def getCenter(grid):
    return (int(len(grid)/2),int(len(grid[0])/2))

def nprint(grid,cur:set=None,sign:str=None):
    for idx,i in enumerate(grid):
        for jdx,j in enumerate(i):
            if (idx,jdx) == cur:
                if len(sign) > 1:
                    print(sign[0]+grid[idx][jdx]+sign[1],end='')
                else:
                    print(sign,end=' ')
            else:                    
                print(grid[idx][jdx],end=' ')
        print()

def list2int(x):
    return list(map(int, x))

def get_re(pattern,str):
    match = re.match(pattern, str)
    if match:
        return match
    return None 

def ppprint(x):
    for idx,i in enumerate(x):
        for jdx,j in enumerate(i):
            print(x[idx][jdx],end='')
        print()

def get_value_in_direction(grid, position, direction=None):
    """
    Get the value in a specified direction from a given position in a grid.
    If no direction is provided, returns the value at the current position.

    Parameters:
        grid (list of list of int/float): The 2D grid.
        position (set): A set containing x (row index) and y (column index) as integers.
        direction (str, optional): The direction to check.
                                   Options: 'up', 'down', 'left', 'right', 
                                            'up-left', 'up-right', 'down-left', 'down-right'.
    
    Returns:
        The value in the grid in the specified direction, or None if out of bounds.
    """
    # Ensure the position is a set of two integers
    if len(position) != 2 or not all(isinstance(coord, int) for coord in position):
        raise ValueError("Position must be a set containing two integers (x, y).")
    
    x, y = position
    offsets = {
        'up': (-1, 0),
        'down': (1, 0),
        'left': (0, -1),
        'right': (0, 1),
        'up-left': (-1, -1),
        'up-right': (-1, 1),
        'down-left': (1, -1),
        'down-right': (1, 1)
    }
    
    # If no direction is given, return the value at the current position
    if direction is None:
        if 0 <= x < len(grid) and 0 <= y < len(grid[x]):
            return grid[x][y]
        else:
            return None

    # Validate direction
    if direction not in offsets:
        raise ValueError(f"Invalid direction: {direction}. Choose from {list(offsets.keys())}")
    
    dx, dy = offsets[direction]
    new_x, new_y = x + dx, y + dy
    
    # Check for out-of-bounds, considering varying row lengths
    if 0 <= new_x < len(grid) and 0 <= new_y < len(grid[new_x]):
        return grid[new_x][new_y]
    else:
        return None