"""Atividade 1 — Mira 2D. PONTO DE PARTIDA.

Aula 02 — Visualização 2D: primitivas gráficas.
Exemplo em Python com PySide6 e PyOpenGL (pipeline fixed-function).

Execute com:

    python mira2d_base.py

O programa já abre a janela, configura o contexto e define a projeção
ortográfica. Ele compila e roda — mas a tela fica vazia, porque o
``paintGL`` ainda não desenha nada.

Sua tarefa é preencher o ``paintGL`` seguindo os TODOs abaixo, até que a
janela mostre a mira da figura de referência. O roteiro completo está na
página da Aula 02.

Antes de começar, responda para si:
  * Qual é a faixa de coordenadas visível na janela? (leia o ``resizeGL``)
  * A mira é centrada na origem — que sinal têm as coordenadas de cada
    canto do quadrado?
"""

from __future__ import annotations

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

# Espessura do traço, em pixels. Ajuste ao comparar com a referência.
ESPESSURA = 5.0


class Mira2D(QOpenGLWidget):
    """Canvas 2D onde a mira deve ser desenhada."""

    def initializeGL(self) -> None:
        # TODO 1 — cor de fundo.
        # A referência tem fundo amarelo. Lembre que o OpenGL usa
        # componentes de 0.0 a 1.0, e não de 0 a 255.
        glClearColor(0.10, 0.11, 0.13, 1.0)

    def resizeGL(self, w: int, h: int) -> None:
        # Pronto: não é preciso alterar nada aqui.
        # O mundo visível vai de -50 a 50 no eixo mais curto da janela,
        # com o eixo mais longo estendido para preservar a proporção.
        w, h = max(1, w), max(1, h)
        glViewport(0, 0, w, h)

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

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

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

        # TODO 2 — cor e espessura do traço.
        #   Qual das duas é estado que vale para os vértices seguintes?
        #   Alguma delas NÃO pode ser chamada entre glBegin e glEnd?

        # TODO 3 — quadrado interno, contorno contínuo.
        #   Escolha a primitiva que liga os vértices em sequência E fecha
        #   o contorno sozinho. Quatro vértices bastam.

        # TODO 4 — quadrado externo, contorno tracejado.
        #   O tracejado é um estado do OpenGL: procure por
        #   glEnable(GL_LINE_STIPPLE), glLineStipple(fator, padrao) e
        #   glDisable(GL_LINE_STIPPLE).
        #   O padrão é um inteiro de 16 bits: cada bit em 1 desenha, cada
        #   bit em 0 pula. O fator multiplica a largura de cada bit.
        #   Desenhe no papel o que 0xAAAA produz antes de testar.

        # TODO 5 — os quatro braços.
        #   Repare na figura: os braços NÃO tocam o centro. Cada braço é
        #   um segmento que começa a alguma distância da origem.
        #   Você consegue desenhar os quatro dentro de UM único
        #   glBegin/glEnd? Qual primitiva permite isso?

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


def main() -> int:
    fmt = QSurfaceFormat()
    fmt.setVersion(2, 1)          # OpenGL 2.1 (fixed-function)
    # NoProfile é o perfil de compatibilidade, que mantém o fixed-function.
    fmt.setProfile(QSurfaceFormat.OpenGLContextProfile.NoProfile)
    fmt.setDepthBufferSize(0)     # cena 2D: sem profundidade
    QSurfaceFormat.setDefaultFormat(fmt)

    app = QApplication(sys.argv)
    window = Mira2D()
    window.setWindowTitle("Atividade 1 — Mira 2D")
    window.resize(640, 480)
    window.show()
    return app.exec()


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