"""Atividade 1 — Aros Olímpicos (ponto de partida).

Aula 03 — Visualização 2D.

Execute com:

    python aros2d_base.py

A janela, o contexto e a projeção já estão prontos. O ``paintGL`` está vazio:
é ele que você vai preencher.

Nesta atividade **não se usa nenhuma transformação geométrica**. Cada aro é
desenhado no lugar em que deve aparecer, com as coordenadas calculadas pela
sua função. Na Aula 04 os mesmos aros serão refeitos com ``glTranslatef``, e
a comparação entre as duas versões é parte do assunto de lá.

Cada TODO corresponde a um passo do roteiro publicado na página da aula.

`Esc` fecha a janela.
"""

from __future__ import annotations

import math
import sys

from PySide6.QtCore import Qt
from PySide6.QtGui import QSurfaceFormat
from PySide6.QtWidgets import QApplication
from PySide6.QtOpenGLWidgets import QOpenGLWidget

from OpenGL.GL import *
from OpenGL.GLU import gluOrtho2D

MUNDO = 50.0        # semilargura da window, em unidades do mundo

# Cores oficiais do símbolo, já normalizadas para o intervalo [0, 1].
AZUL = (0.00, 0.51, 0.78)
PRETO = (0.00, 0.00, 0.00)
VERMELHO = (0.93, 0.20, 0.31)
AMARELO = (0.99, 0.69, 0.19)
VERDE = (0.00, 0.65, 0.32)


class Aros2D(QOpenGLWidget):
    """Os cinco aros olímpicos, sem transformações geométricas."""

    def initializeGL(self) -> None:
        # TODO 2 — o símbolo pede fundo claro: o aro preto some no escuro.
        glClearColor(0.10, 0.11, 0.13, 1.0)

    def resizeGL(self, w: int, h: int) -> None:
        w, h = max(1, w), max(1, h)
        glViewport(0, 0, w, h)

        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        if w <= h:
            gluOrtho2D(-MUNDO, MUNDO, -MUNDO * h / w, MUNDO * h / w)
        else:
            gluOrtho2D(-MUNDO * w / h, MUNDO * w / h, -MUNDO, MUNDO)

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

    # TODO 3 — escreva a função que desenha UM aro.
    #
    #   @staticmethod
    #   def _desenhar_aro(cx, cy, raio, cor):
    #       ...
    #
    # Ela deve emitir os vértices de uma circunferência de centro (cx, cy) e
    # raio `raio`, com a primitiva que liga os vértices em sequência E fecha
    # o contorno sozinho. Consulte a tabela de primitivas da Aula 02.
    #
    # Repare que a função recebe o centro como parâmetro: é isso que permite
    # desenhar cinco aros em cinco lugares diferentes sem transformação
    # nenhuma — as coordenadas já saem prontas do cálculo.

    def paintGL(self) -> None:
        glClear(GL_COLOR_BUFFER_BIT)

        # TODO 4 — espessura do traço.
        # TODO 5 — desenhe os cinco aros, na cor e na posição corretas.

    def keyPressEvent(self, event) -> None:
        if event.key() == Qt.Key.Key_Escape:
            self.close()


def main() -> int:
    fmt = QSurfaceFormat()
    fmt.setVersion(2, 1)
    fmt.setProfile(QSurfaceFormat.OpenGLContextProfile.NoProfile)
    fmt.setDepthBufferSize(0)
    QSurfaceFormat.setDefaultFormat(fmt)

    app = QApplication(sys.argv)
    janela = Aros2D()
    janela.setWindowTitle("Atividade 1 — Aros Olímpicos")
    janela.resize(760, 480)
    janela.show()
    return app.exec()


if __name__ == "__main__":
    raise SystemExit(main())