import numpy as np
import pygame as pg

def create_matrix(n: int):
    return np.arange(1, n ** 2 + 1).reshape(n, n)

m_3 = [[[1, 0], [0, 0], [1, 2], [2, 2]], [[2, 0], [2, 1], [0, 2], [0, 1]]]
m_4 = [[[0, 0], [2, 2]], [[1, 0], [0, 1]],
       [[2, 0], [3, 1]], [[3, 0], [1, 2]],
       [[0, 2], [1, 3]], [[1, 1], [3, 3]],
       [[2, 1], [0, 3]], [[3, 2], [2, 3]]]

# _m - input matrix, _x - base row length
def m_split(_m, _x):
    return [np.vsplit(x, _x) for x in np.hsplit(_m, _x)]
# _m - input "previous splitted" matrix, _x - base row length
def m_join(_m, _x):
    return np.vstack([np.hstack(np.vstack(_m)[x::_x]) for x in range(_x)])

# _m - input "previous splitted" matrix, idxs - indices of matrix cells.
def m_rot(_m, idxs):
    #      [-----X----][-----Y----]
    a0 = _m[idxs[0][0]][idxs[0][1]]
    for i in range(len(idxs) - 1):
        _m[idxs[i][0]][idxs[i][1]] = _m[idxs[i + 1][0]][idxs[i + 1][1]]
    _m[idxs[-1][0]][idxs[-1][1]] = a0
    return _m
#_m - input "previous splitted" matrix, _steps - pattern of digits swaps (m_3, m_r, ...)...
def magic_steps(_m, _steps):
    m0 = _m
    for step in _steps:
        m0 = m_rot(m0, step)
    return m0

# _mss - magic steps (m_3, m_4, or ...)
def pow_square(_root, _pow, _mss):
    m_dmag = lambda x, d: m_join(magic_steps(m_split(x, d), _mss), d)
    _p = _root ** _pow
    m0 = m_dmag(create_matrix(_p), _root)
    for i in range(1, _pow):
        m0 = m_join([[m_dmag(x, _root) for x in y] for y in m_split(m0, _root ** i)], _root ** i)
    return m0

# returns list of [list of coordinates for all moved digits in move-chain]
def get_cycles(_m):
    ret = []
    dim = len(_m)
    used = []
    j_to_xy = lambda _j, _d: [(_j - 1) % _d, int((_j - 1) / _d)]
    xy_to_j = lambda _xy, _d: _xy[0] + _xy[1] * _d + 1
    for j in range(1, dim * dim + 1):
        _p = []
        x, y = j_to_xy(j, dim)
        if _m[y][x] in used:
            continue
        if _m[y][x] == j:
            used += [_m[y][x]]
            continue
        _p += [[x, y]]
        while True:
            a = _m[y][x]
            x, y = j_to_xy(a, dim)
            _p += [[x, y]]
            used += [a]
            if xy_to_j([x, y], dim) == j:
                ret += [_p]
                break
    return ret
# returns list of digits, that's just stay on their base coordinates.
def get_statics(_m):
    dim = len(_m)
    j_to_xy = lambda _j, _d: [(_j - 1) % _d, int((_j - 1) / _d)]
    ret = []
    for j in range(1, dim * dim + 1):
        x, y = j_to_xy(j, dim)
        if _m[y][x] == j:
            ret += [[x, y]]
    return ret
# drawing function.
def to_star(_m):
    # compute optimal window width\height (d_sz) and step length multiplier (sz)...
    dim = len(_m)
    max_sz = 1000
    _sz = int(max_sz / dim)
    sz = 20 if _sz > 20 else 1 if _sz == 0 else _sz
    d_sz = (sz * dim + 20, sz * dim + 20)
    # initialize PyGame window and drawing field:
    pygame.init()
    _sc = pygame.display.set_mode(d_sz)
    _sc.fill((255, 255, 255))
    pg.display.flip()
    # begin drawing
    for _c in get_cycles(_m):
        sc = _sc.convert_alpha()
        sc.fill([0, 0, 0, 0])
        # scale coordinates with computed step length multiplier (sz)
        # last point excluded, as it is equals to the first.
        points = [(x * sz + 10, y * sz + 10) for x, y in _c[:-1]]
        # draw line or polygon between the coordinates of the moved numbers
        # lines have 55% opacity.
        r = pg.draw.lines(sc, (0, 0, 0, 15), True, points) \
            if len(points) > 2 \
            else pg.draw.line(sc, (0, 0, 0, 55), points[0], points[1])
        _sc.blit(sc, (0, 0))
        pg.display.update(r)
    for _s in [(x * sz + 10, y * sz + 10) for x, y in get_statics(_m)]:
        # draw small yellow circle on the coordinates of the numbers
        # that have retained their positions
        r = pg.draw.circle(_sc, (200, 200, 0, 70), _s, 5)
        pg.display.update(r)
    # end drawing, wait for exit.
    c = pg.time.Clock()
    while True:
        c.tick(60)
        for events in pg.event.get():
            if events.type == pg.QUIT:
                pg.quit()
        pygame.display.update()

if __name__ == '__main__':
    pow = 3
    root = 4
    m1 = pow_square(root, pow, m_4)
    try:
        to_star(m1)
    except pygame.error:
        print('Drawing finished.')
    print(m1)
    # Compute sums of all digits in rows, columns and diagonals.
    m2 = np.rot90(m1)
    print([sum(x) for x in m1])
    print([sum(x) for x in m2])
    print(sum([m1[x, x] for x in range(root ** pow)]))
    print(sum([m2[x, x] for x in range(root ** pow)]))