"""Atividade T2 — quatro composições de transformações geométricas 2D.

Adaptação da atividade original em OpenGL+IUP/C++ para PySide6+PyOpenGL.
A janela representa o SRU de -100 a 100 nos dois eixos. Os eixos x e y
dividem a cena nos quatro quadrantes cartesianos.

Complete os TODOs sem alterar os vértices das quatro funções de desenho.
Cada objeto deve ser posicionado exclusivamente pela matriz GL_MODELVIEW.

Execute com:

    python t2_transformacoes2d_base.py

Esc fecha a janela.
"""

from __future__ import annotations

import sys

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

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


LIMITE = 100.0


def desenhar_casa() -> None:
    """Casa local cuja origem p1=(0,0) é o canto inferior esquerdo."""
    glColor3f(0.12, 0.35, 0.95)
    glBegin(GL_QUADS)
    glVertex2f(0.0, 0.0)
    glVertex2f(32.0, 0.0)
    glVertex2f(32.0, 28.0)
    glVertex2f(0.0, 28.0)
    glEnd()

    glColor3f(0.95, 0.12, 0.12)
    glBegin(GL_TRIANGLES)
    glVertex2f(-3.0, 28.0)
    glVertex2f(35.0, 28.0)
    glVertex2f(16.0, 45.0)
    glEnd()

    glColor3f(0.95, 0.95, 0.95)
    glBegin(GL_QUADS)
    glVertex2f(12.0, 0.0)
    glVertex2f(21.0, 0.0)
    glVertex2f(21.0, 18.0)
    glVertex2f(12.0, 18.0)
    for x0 in (3.0, 24.0):
        glVertex2f(x0, 14.0)
        glVertex2f(x0 + 6.0, 14.0)
        glVertex2f(x0 + 6.0, 21.0)
        glVertex2f(x0, 21.0)
    glEnd()


def desenhar_triangulo_retangulo() -> None:
    """Triângulo centrado aproximadamente na origem local."""
    glColor3f(0.95, 0.95, 0.95)
    glBegin(GL_TRIANGLES)
    glVertex2f(-12.0, -8.0)
    glVertex2f(12.0, -8.0)
    glVertex2f(-12.0, 16.0)
    glEnd()


def desenhar_quadrado() -> None:
    """Quadrado de lado 10, centrado na origem local."""
    glColor3f(1.0, 0.92, 0.05)
    glBegin(GL_QUADS)
    glVertex2f(-5.0, -5.0)
    glVertex2f(5.0, -5.0)
    glVertex2f(5.0, 5.0)
    glVertex2f(-5.0, 5.0)
    glEnd()


def desenhar_losango() -> None:
    """Losango horizontal, centrado na origem local."""
    glColor3f(0.05, 0.95, 0.20)
    glBegin(GL_QUADS)
    glVertex2f(-18.0, 0.0)
    glVertex2f(0.0, 10.0)
    glVertex2f(18.0, 0.0)
    glVertex2f(0.0, -10.0)
    glEnd()


class AtividadeT2(QOpenGLWidget):
    def initializeGL(self) -> None:
        glClearColor(0.0, 0.0, 0.0, 1.0)

    def resizeGL(self, w: int, h: int) -> None:
        dpr = self.devicePixelRatioF()
        fb_w = max(1, round(w * dpr))
        fb_h = max(1, round(h * dpr))
        glViewport(0, 0, fb_w, fb_h)

        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        aspecto = fb_w / float(fb_h)
        if aspecto >= 1.0:
            gluOrtho2D(-LIMITE * aspecto, LIMITE * aspecto, -LIMITE, LIMITE)
        else:
            gluOrtho2D(-LIMITE, LIMITE, -LIMITE / aspecto, LIMITE / aspecto)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

    @staticmethod
    def _desenhar_eixos() -> None:
        glColor3f(0.20, 0.75, 0.25)
        glLineWidth(2.0)
        glBegin(GL_LINES)
        glVertex2f(-200.0, 0.0)
        glVertex2f(200.0, 0.0)
        glVertex2f(0.0, -200.0)
        glVertex2f(0.0, 200.0)
        glEnd()

    def paintGL(self) -> None:
        glClear(GL_COLOR_BUFFER_BIT)
        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()
        self._desenhar_eixos()

        # TODO 1 — 1º quadrante: desenhe a casa com a origem local p1
        # posicionada em (5, 5). A casa é estática: use somente translação.

        # TODO 2 — 2º quadrante: posicione o triângulo no centro aproximado
        # (-50, 50) e rotacione-o 45° em torno da própria origem. Isole a
        # composição com glPushMatrix/glPopMatrix.

        # TODO 3 — 3º quadrante: aumente o quadrado 3x e posicione-o junto à
        # parte superior esquerda do quadrante. A solução de referência usa
        # o centro (-85, -15).

        # TODO 4 — 4º quadrante: aplique ao losango a translação (-30, -50)
        # PRIMEIRO e a rotação de 90° DEPOIS. Lembre que, no código OpenGL,
        # a chamada mais próxima do desenho afeta os vértices primeiro.

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


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

    app = QApplication(sys.argv)
    janela = AtividadeT2()
    janela.setWindowTitle("T2 — Transformações Geométricas 2D")
    janela.resize(900, 650)
    janela.show()
    return app.exec()


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