def flood_fill(used: [])
  new_dim = @dim * 3
  new_map = Array.new(new_dim.size, '.')

  puts "Expanding #{@dim} to #{new_dim}, with #{used.size} visited pipes." if $args.verbose

  # Mark all real points as inside on the expanded map
  (0..(@dim.y - 1)).each do |y|
    (0..(@dim.x - 1)).each do |x|
      expanded_point = Point.new x * 3 + 1, y * 3 + 1
      new_map[expanded_point.y * new_dim.x + expanded_point.x] = 'I'
    end
  end

  # Paint all used pipes onto the expanded map
  used.each do |used_p|
    expanded_point = Point.new used_p.x * 3 + 1, used_p.y * 3 + 1

    new_map[expanded_point.y * new_dim.x + expanded_point.x] = '#'
    offsets = @links[used_p].connections
    offsets.shift

    offsets.each do |offs|
      diff = offs - used_p
      new_map[(expanded_point.y + diff.y) * new_dim.x + (expanded_point.x + diff.x)] = '#'
    end
  end

  puts "Flooding expanded map..." if $args.verbose

  # Flood fill the expanded map from the top-left corner
  to_visit = [Point.new(0, 0)]
  until to_visit.empty?
    at = to_visit.shift
    new_map[at.y * new_dim.x + at.x] = ' '

    (-1..1).each do |off_y|
      (-1..1).each do |off_x|
        next if (off_x.zero? && off_y.zero?) || !(off_x.zero? || off_y.zero?)

        off_p = at + Point.new(off_x, off_y)
        next if off_p.x < 0 || off_p.y < 0 \
          || off_p.x >= new_dim.x || off_p.y >= new_dim.y \
          || to_visit.include?(off_p)

        val = new_map[off_p.y * new_dim.x + off_p.x]
        next unless %w[. I].include? val

        to_visit << off_p
      end
    end
  end

  return new_map, new_dim
end

namespace AdventOfCode2023.Days.Ten
{
    internal class Day10Task1 : IRunnable
    {
        private HashSet<(int, int)> _visitedNodes = new HashSet<(int, int)>();

        public void Run()
        {
            //var inputLines = File.ReadAllLines("Days/Ten/Day10ExampleInput.txt");
            //var inputLines = File.ReadAllLines("Days/Ten/Day10ExampleInput2.txt");
            var inputLines = File.ReadAllLines("Days/Ten/Day10Input.txt");

            var map = new PipeMap(inputLines);
            _visitedNodes.Add((map.XCoord, map.YCoord));

            while (true)
            {
                bool haveMoved = false;
                for (int i = 0; i < 4; i++)
                {
                    if (map.CanMove((Direction)i))
                    {
                        map.Move((Direction)i);
                        if (_visitedNodes.Contains((map.XCoord, map.YCoord)))
                        {
                            map.Move(GetOppositeDirection((Direction)i));
                        }
                        else
                        {
                            _visitedNodes.Add((map.XCoord, map.YCoord));
                            haveMoved = true;
                        }
                    }
                }

                if (!haveMoved)
                {
                    break;
                }
            }

            Console.WriteLine("Nodes Visited: "+ _visitedNodes.Count);
            Console.WriteLine("Furthest Node: "+ _visitedNodes.Count/2);

        }




        public class PipeMap
        {
            public int XCoord { get; private set; }
            public int YCoord { get; private set; }
            public char CurrentPipe { get { return Map[YCoord][XCoord]; } }

            private string[] Map { get; set; }

            public PipeMap(string[] mapString)
            {
                Map = mapString;

                for (int y = 0; y < mapString.Length; y++)
                {
                    for (int x = 0; x < mapString[y].Length; x++)
                    {
                        if (mapString[y][x] == 'S')
                        {
                            YCoord = y;
                            XCoord = x;
                        }
                    }
                }
            }

            public void Move(Direction direction)
            {
                var adjacent = GetAdjacent(direction);

                XCoord = adjacent.Item1;
                YCoord = adjacent.Item2;
            }

            public bool CanMove(Direction direction)
            {
                bool currentPositionAllow = CanMoveFromCoord(direction, XCoord, YCoord);

                if (!currentPositionAllow) return false;

                var adjacent = GetAdjacent(direction);

                if (adjacent.Item3 != '.' && CanMoveFromCoord(GetOppositeDirection(direction), adjacent.Item1, adjacent.Item2))
                {
                    return true;
                }

                return false;
            }

            private bool CanMoveFromCoord(Direction direction, int xCoord, int yCoord)
            {
                switch (Map[yCoord][xCoord])
                {
                    case '|':
                        return direction == Direction.Up || direction == Direction.Down;
                    case '-':
                        return direction == Direction.Left || direction == Direction.Right;
                    case 'L':
                        return direction == Direction.Up || direction == Direction.Right;
                    case 'J':
                        return direction == Direction.Up || direction == Direction.Left;
                    case '7':
                        return direction == Direction.Left || direction == Direction.Down;
                    case 'F':
                        return direction == Direction.Right || direction == Direction.Down;
                    case 'S':
                        return true;
                    case '.':
                    default:
                        throw new Exception("you dun fucked up");
                }
            }

            private (int, int, char) GetAdjacent(Direction direction)
            {
                var newXCoord = XCoord;
                var newYCoord = YCoord;

                switch (direction)
                {
                    case Direction.Up:
                        newYCoord--;
                        break;
                    case Direction.Down:
                        newYCoord++;
                        break;
                    case Direction.Left:
                        newXCoord--;
                        break;
                    case Direction.Right:
                        newXCoord++;
                        break;
                }

                return (newXCoord, newYCoord, Map[newYCoord][newXCoord]);
            }
        }

        public enum Direction
        {
            Up, Right, Down, Left
        }

        public static Direction GetOppositeDirection(Direction direction)
        {
            switch (direction)
            {
                case Direction.Up:
                    return Direction.Down;
                case Direction.Down:
                    return Direction.Up;
                case Direction.Right:
                    return Direction.Left;
                case Direction.Left:
                    return Direction.Right;
                default: throw new Exception("You dun fucked up... again");
            }
        }
    }


}

use v6;

sub MAIN($input) {
    my $file = open $input;

    my @map = $file.lines».comb».Array;

    my @starting-point = @map».grep('S', :k)».[0].grep(*.defined, :kv).List;

    my @path = (@starting-point,);

    my %tile-neighbors =
        '|' => (( 1, 0),(-1, 0)),
        '-' => (( 0,-1),( 0, 1)),
        'L' => ((-1, 0),( 0, 1)),
        'J' => ((-1, 0),( 0,-1)),
        '7' => (( 1, 0),( 0,-1)),
        'F' => (( 1, 0),( 0, 1)),
    ;

    sub connecting-neighbor(@position, @neighbor) {
        my @neighbor-position = @position Z+ @neighbor;
        return False if any(@neighbor-position Z< (0, 0));
        return False if any(@neighbor-position Z> (@map.end, @map.head.end));
        my $neighbor-tile = @map[@neighbor-position[0]; @neighbor-position[1]];
        my @negative-neighbor = @neighbor X* -1;
        return %tile-neighbors{$neighbor-tile}.grep(@negative-neighbor, :k).elems > 0;
    }

    # replace starting-point with the appropriate pipe
    my @start-tile-candidates = <| - L J 7 F>;
    for @start-tile-candidates -> $candidate {
        next if %tile-neighbors{$candidate}.map({!connecting-neighbor(@starting-point, $_)}).any;
        @map[@starting-point[0]; @starting-point[1]] = $candidate;
        last;
    }

    repeat {
        my @position := @path.tail;
        my $tile = @map[@position[0]; @position[1]];
        my @neighbors = %tile-neighbors{$tile}.List;
        for @neighbors -> @neighbor {
            my @neighbor-position = @neighbor Z+ @position;
            next if @path.elems >= 2 && @neighbor-position eqv @path[*-2];
            if connecting-neighbor(@position, @neighbor) {
                @path.push(@neighbor-position);
                last;
            }
        }
    } while @path.tail !eqv @path.head;
    my $part-one-solution = (@path.elems / 2).floor;
    say "part 1: {$part-one-solution}";

    my %pipe-set = @path.Set;
    my %same-side-pairs = ;
    my $part-two-solution = 0;
    for ^@map.elems -> $y {
        my $inside = False;
        my $entrance-pipe = Nil;
        for ^@map.head.elems -> $x {
            if %pipe-set{$($y, $x)} {
                given @map[$y; $x] {
                    when '|' { $inside = !$inside }
                    when 'F' | 'L' { $entrance-pipe = $_ }
                    when 'J' | '7' {
                        $inside = !$inside if %same-side-pairs{$entrance-pipe} ne $_;
                        $entrance-pipe = Nil;
                    }
                }
            } elsif $inside {
                $part-two-solution += 1;
            }
        }
    }
    say "part 2: $part-two-solution";
}

class Connection(Flag):
    Empty = 0b0000
    North = 0b0001
    South = 0b0010
    East = 0b01000
    West = 0b10000

def connected_directions(first:Connection,second:Connection) -> bool:
    return bool(((first.value >> 1) & second.value) or
            ((first.value << 1) & second.value))

def opposite_direction(dir:Connection) -> Connection:
    if dir.value & 0b00011:
        return Connection(dir.value ^ 0b00011)
    if dir.value & 0b11000:
        return Connection(dir.value ^ 0b11000)
    return Connection(0)

class PipeElement:
    def __init__(self,symbol:chr) -> None:
        self.symbol = symbol
        self.connection = Connection.Empty
        if symbol in [*'|LJS']:
            self.connection |= Connection.North
        if symbol in [*'|7FS']:
            self.connection |= Connection.South
        if symbol in [*'-LFS']:
            self.connection |= Connection.East
        if symbol in [*'-J7S']:
            self.connection |= Connection.West
        if self.connection == Connection.Empty:
            self.symbol = '.'

    def __repr__(self) -> str:
        return f"Pipe({self.connection})"
    
    def __str__(self) -> str:
        return self.symbol

    def connected_to(self,pipe,direction:Connection) -> bool:
        if not (self.connection & direction):
            return False
        
        if self.connection & direction and pipe.connection & opposite_direction(direction):
            return True
        
        return False
        
class Navigator:
    def __init__(self,list:list,width) -> None:
        self.list = list
        self.width = width

    def at(self,position):
        return self.list[position]
    
    def neighbor(self,position,direction:Connection) -> tuple | None:
        match direction:
            case Connection.North:
                return self.prev_row(position)
            case Connection.South:
                return self.next_row(position)
            case Connection.East:
                return self.next(position)
            case Connection.West:
                return self.prev(position)
        raise Exception(f"Direction not found: {direction}")

    def prev_row(self,position) -> tuple | None:
        p = position - self.width
        if p < 0:
            return None
        return (p,self.list[p])

    def next_row(self,position) -> tuple | None:
        p = position + self.width
        if p >= len(self.list):
            return None
        return (p,self.list[p])
    
    def prev(self,position) -> tuple | None:
        p = position - 1
        if p < 0:
            return None
        return (p,self.list[p])

    def next(self,position) -> tuple | None:
        p = position + 1
        if p >= len(self.list):
            return None
        return (p,self.list[p])
    
    def all_neighbors(self,position) -> list:
        l = list()
        for f in [self.next, self.prev, self.next_row,self.prev_row]:
            t = f(position)
            if t != None:
                l.append(t)
        return l
    
    def find_connected(self,position,exclude=Connection.Empty) -> tuple | None:
        for dir in [Connection.East,Connection.West,Connection.North,Connection.South]:
            if dir == exclude:
                continue

            n = self.neighbor(position,dir)
            if n == None:
                continue

            if self.at(position).connected_to(n[1],dir):
                return (*n,dir)
        return None

class TileType(Enum):
    Inside = 1
    Outside = 0
    Pipe = 2
    PlaceHolder = 3

def pipe_to_tile_expand(pipe:PipeElement) -> list:
    s = str(pipe)
    expansions = {
        '.': '.PP'+ 'PPP' + 'PPP',
        '-': 'PPP'+ '---' + 'PPP',
        '|': 'P|P'+ 'P|P' + 'P|P',
        'F': 'PPP'+ 'PF-' + 'P|P',
        '7': 'PPP'+ '-7P' + 'P|P',
        'J': 'P|P'+ '-JP' + 'PPP',
        'L': 'P|P'+ 'PL-' + 'PPP',
        'S': 'P|P'+ '-S-' + 'P|P'
        }
    l = expansions[s]
    return [pipe_to_tile(x) for x in [*l]]
def pipe_to_tile(pipe:str) -> TileType:
    expansions = {
        '.': TileType.Inside,
        '-': TileType.Pipe,
        '|': TileType.Pipe,
        'F': TileType.Pipe,
        '7': TileType.Pipe,
        'J': TileType.Pipe,
        'L': TileType.Pipe,
        'S': TileType.Pipe,
        'P': TileType.PlaceHolder
        }
    return expansions[pipe]

def chunks(lst, n):
    """Yield successive n-sized chunks from lst."""
    for i in range(0, len(lst), n):
        yield lst[i:i + n]

def print_tiles(tile_list:list,width:int):
    for c in chunks(tile_list,width):
        print("".join([str(t.value) for t in c]))

def print_pipes(tile_list:list,width:int):
    for c in chunks(tile_list,width):
        print("".join([str(t) for t in c]))

def main(line_list:list,part:int):
    width = None

    pipe_list = list()
    tile_list = list()
    start_o = None
    for line in line_list:
        line = line + ' ' # stops east/west joining over new lines
        if width == None:
            width = len(line)
        for c in [*line]:
            o = PipeElement(c)
            pipe_list.append(o)
            tile_list.append(TileType.Inside)
            if c == 'S':
                start_o = o
    #print(pipe_list)
    start_pos = pipe_list.index(start_o)
    start_co = (start_pos // width, start_pos % width)
    print(f"starting index: {start_pos}: {start_co}")

    nav = Navigator(pipe_list,width)

    cur_pos = None
    last_dir = Connection.Empty
    steps = 0
    while cur_pos != start_pos:
        if cur_pos == None:
            cur_pos = start_pos
        
        pipe = nav.find_connected(cur_pos,exclude=opposite_direction(last_dir))
        if pipe == None:
            raise Exception(f"end of pipe at: {cur_pos}, {nav.at(cur_pos)}")
        cur_pos = pipe[0]
        last_dir = pipe[2]
        steps += 1
        #print(f"{cur_pos}->",end="")

        tile_list[cur_pos] = TileType.Pipe
    
    print(f"end: {cur_pos}, steps: {steps}")

    clean_pipe = list()
    for i in range(0,len(pipe_list)):
        if tile_list[i] == TileType.Pipe:
            clean_pipe.append(pipe_list[i])
        else:
            clean_pipe.append(PipeElement('.'))

    print_pipes(clean_pipe,width)
    print(f"part 1: {steps/2}")

    # part 2 outputs
    #print("start tile:")
    #print_tiles(tile_list,width)

    # add outsides to edge of map
    tile_list2 = list()
    #first row
    expanded_width = (width*3)+2
    for i in range(0,expanded_width):
        tile_list2.append(TileType.Outside)
    for row in chunks(clean_pipe, width):
        ## we need to expand this to 2x size tiles
        t_rows = [ list() for x in range(0,3)]
        [ x.append(TileType.Outside) for x in t_rows]
        for r in row:
            parts = pipe_to_tile_expand(r)
            [ t_rows[x].extend( parts[x*3:(x*3)+3] ) for x in range(0,3)]
        [ x.append(TileType.Outside) for x in t_rows]
        [ tile_list2.extend(x) for x in t_rows]
    for i in range(0,expanded_width):
        tile_list2.append(TileType.Outside)

    #print("with o tile:")
    #print_tiles(tile_list2,width+2)

    tilenav = Navigator(tile_list2,expanded_width)
    changes = True
    while changes == True:
        changes = False
        count_in = 0
        
        for i in range(0,len(tile_list2)):
            t = tilenav.at(i)
            if t == TileType.Inside or t == TileType.PlaceHolder:
                n = tilenav.all_neighbors(i)
                if any([x[1] == TileType.Outside for x in n]):
                    tilenav.list[i] = TileType.Outside
                    changes = True
                    continue
                if t == TileType.Inside:
                    count_in += 1

    print("with outside tile:")
    print_tiles(tile_list2,expanded_width)
    print(count_in)

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="template for aoc solver")
    parser.add_argument("-input",type=str)
    parser.add_argument("-part",type=int)
    args = parser.parse_args()
    filename = args.input
    if filename == None:
        parser.print_help()
        exit(1)
    part = args.part
    file = open(filename,'r')
    main([line.rstrip('\n') for line in file.readlines()],part)
    file.close()

proc solve*(input:string):array[2, int]=
  let lines = input.readFile.strip.splitLines.filterIt(it.len != 0)
  
  # build grid
  var grid = Grid(width:lines[0].len, height:lines.len)
  for line in lines:
    grid.tiles.add(line.mapIt(Tile(shape:it)))
  
  # resolve tile connections
  for t in grid.tiles:
    t.connections = shapeConnections[t.shape]
  
  # find start coordinates and resolve connections for it
  let startCoords = grid.find('S')
  let startTile = grid[startCoords]
  startTile.connections = startCoords.findConnections(grid)
  startTile.distance = 0
  
  # Traverse both ends of path from start
  var open: Deque[Coord]
  open.addLast(startCoords)
  
  while open.len != 0:
    let c = open.popFirst # current coordinate
    let ct = grid[c] # tile at c
    
    #find and add connected neighbour nodes
    for d in ct.connections:
      let n = c+d
      let nt = grid[n]
      # if not already on found path and not in open tiles
      if nt.distance == -1 and not (n in open):
        nt.distance = ct.distance + 1
        result[0] = max(result[0], nt.distance)
        open.addLast(n)
    
  # Part 2
  for c in grid:
    let ct = grid[c]
    
    #path tiles are never counted
    if ct.distance >= 0:
      continue
    
    # search from tile to end of row
    var enclosed = false
    for sx in c.x.. 0):
        enclosed = not enclosed
      
    result[1] += ord(enclosed)