<p>You are given two integers <code>m</code> and <code>n</code>, which represent the dimensions of a matrix.</p>

<p>You are also given the <code>head</code> of a linked list of integers.</p>

<p>Generate an <code>m x n</code> matrix that contains the integers in the linked list presented in <strong>spiral</strong> order <strong>(clockwise)</strong>, starting from the <strong>top-left</strong> of the matrix. If there are remaining empty spaces, fill them with <code>-1</code>.</p>

<p>Return <em>the generated matrix</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/05/09/ex1new.jpg" style="width: 240px; height: 150px;" />
<pre>
<strong>Input:</strong> m = 3, n = 5, head = [3,0,2,6,8,1,7,9,4,2,5,5,0]
<strong>Output:</strong> [[3,0,2,6,8],[5,0,-1,-1,1],[5,2,4,9,7]]
<strong>Explanation:</strong> The diagram above shows how the values are printed in the matrix.
Note that the remaining spaces in the matrix are filled with -1.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/05/11/ex2.jpg" style="width: 221px; height: 60px;" />
<pre>
<strong>Input:</strong> m = 1, n = 4, head = [0,1,2]
<strong>Output:</strong> [[0,1,2,-1]]
<strong>Explanation:</strong> The diagram above shows how the values are printed from left to right in the matrix.
The last space in the matrix is set to -1.</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li>
	<li>The number of nodes in the list is in the range <code>[1, m * n]</code>.</li>
	<li><code>0 &lt;= Node.val &lt;= 1000</code></li>
</ul>

# You are given two integers m and n, which represent the dimensions of a matrix.

# You are also given the head of a linked list of integers.

# Generate an m x n matrix that contains the integers in the linked list presented in spiral order (clockwise), starting from the top-left of the matrix. If there are remaining empty spaces, fill them with -1.

# Return the generated matrix.

# Definition for singly-linked list.
from typing import Optional, List


class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        matrix = [[-1 for i in range(n)] for i in range(m)]
        keep_going = True
        
        for ni, mi in self.generate_coords(n, m):
            if keep_going:
                matrix[mi][ni] = head.val
            
            if head.next != None:
                head = head.next
            else:
                keep_going = False
        
        return matrix
    
    # I hate this fucking hell spawn of a function
    # I really need to get better at geometry...
    def generate_coords(self, x_len: int, y_len: int):
        squares = x_len*y_len
        coord = (0, 0)
        dir = (1, 0)
        rotate_at = x_len
        vert = False
        
        for i in range(squares):
            # ALMOST THERE
            # Just need to check the rotate_at logic
            if i == rotate_at -1:
                dir = rotate90(*dir)
                
                vert = not vert
                if vert:
                    y_len-=1
                    rotate_at += y_len
                else:
                    x_len -=1
                    rotate_at += x_len
            
            
            # Always start from 0, 0
            yield coord
            coord = (coord[0] + dir[0], coord[1] + dir[1])
            

def rotate90(x, y) -> tuple:
    buf = x
    x = -y
    y = buf
    
    return (x, y)

s = Solution()
for c in s.generate_coords(5, 3):
    print(c)
836