def layer1(self) -> tuple:
    """
    Solve first layer corners.

    Returns
    -------
    tuple of (list of str, dict of {'FIRST LAYER': int})
        Moves to solve first layer, statistics (move count in ETM).

    Notes
    -----
    A corner on the top layer with a white sticker is rotated so that
    it is directly above the correct position at the front-right slot.
    Then repeatedly do `R U R' U'` until the corner is correctly
    inserted.

    If there are no more corners with a white sticker on the top layer
    and the first layer is still unsolved, an unsolved corner with a
    white sticker on the bottom layer is rotated to the front-right slot
    and moved to the top layer by doing `R U R' U'`.

    Repeat until the first layer is solved.
    """
    cube = self.cube
    solve = []
    corners = (0,0), (0,-1), (-1,0), (-1,-1)
    first_layer = (
        ((0,-1,-1), (2,0,-1), (3,0,0)),
        ((0,-1,0), (1,0,-1), (2,0,0)),
        ((0,0,-1), (3,0,-1), (4,0,0)),
        ((0,0,0), (4,0,-1), (1,0,0))
    )

    while not(all(cube[5][y][x] == 'U' for y, x in corners) and
              all(len(set(side[-1])) == 1 for side in cube[1:5])):
        for corner in first_layer:
            if any(cube[x[0]][x[1]][x[2]] == 'U' for x in corner):
                break
        else:
            if cube[5][0][-1] != 'U' or cube[2][-1][-1] != cube[2][1][1]:
                pass
            elif cube[5][0][0] != 'U' or cube[1][-1][-1] != cube[1][1][1]:
                self.move("y'")
                solve.append("y'")
            elif cube[5][-1][-1] != 'U' or cube[3][-1][-1] != cube[3][1][1]:
                self.move('y')
                solve.append('y')
            else:
                self.move('y2')
                solve.append('y2')

            moves = 'R', 'U', "R'", "U'"
            self.move(moves)
            solve.extend(moves)
            continue

        piece = []
        for x in corner:
            piece.append(cube[x[0]][x[1]][x[2]])

        slot = piece[piece.index('U') - 1]
        for s, side in enumerate(cube[1:5], 1):
            if side[1][1] == slot:
                slot = s - 1
                break

        piece = corner[1][0] - 1
        turns = (piece - slot) % 4

        if turns == 1:
            self.move('U')
            solve.append('U')
        elif turns == 2:
            self.move('U2')
            solve.append('U2')
        elif turns == 3:
            self.move("U'")
            solve.append("U'")

        if  not slot:
            self.move("y'")
            solve.append("y'")
        elif slot == 2:
            self.move('y')
            solve.append('y')
        elif slot == 3:
            self.move('y2')
            solve.append('y2')

        while cube[5][0][-1] != 'U' or cube[2][-1][-1] != cube[2][-1][1]:
            moves = 'R', 'U', "R'", "U'"
            self.move(moves)
            solve.extend(moves)

    return solve, {'FIRST LAYER': len(solve)}