package com.example.lab5v2024_2025

import android.opengl.GLSurfaceView
import javax.microedition.khronos.egl.EGLConfig
import javax.microedition.khronos.opengles.GL10
import android.opengl.GLU
import java.nio.ByteBuffer
import java.nio.ByteOrder
import java.nio.FloatBuffer
import kotlin.math.cos
import kotlin.math.sin

class MyRenderer : GLSurfaceView.Renderer {
    private var angle = 0f // kąt do obracania figury na płótnie
    private var ballX = 0f // pozycja piłki w osi X
    private var ballY = 0f // pozycja piłki w osi Y
    private var ballRadius = 0f // promień piłki (10% długości dłuższej krawędzi)
    private var speedX = 0.01f // prędkość w osi X
    private var speedY = 0f // prędkość w osi Y (brak ruchu w osi Y)
    private var screenWidth = 1f // szerokość ekranu
    private var screenHeight = 1f // wysokość ekranu


    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {

        gl?.glClearColor(0.0f, 1.0f, 0.0f, 1.0f)
    }

    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
        screenWidth = width.toFloat() / height.toFloat()
        screenHeight = 1f
        gl?.glViewport(0, 0, width, height)
        gl?.glMatrixMode(GL10.GL_PROJECTION)
        gl?.glLoadIdentity()
        GLU.gluOrtho2D(gl, -screenWidth, screenWidth, -1f, 1f)

        val longerSide = if (width > height) width.toFloat() else height.toFloat()
        ballRadius = 0.1f * longerSide / height // 10% długości dłuższej krawędzi
    }

    override fun onDrawFrame(gl: GL10?) {
        // Czyścimy bufor kolorów
        gl?.glClear(GL10.GL_COLOR_BUFFER_BIT)

        // Aktualizacja pozycji piłki
        ballX += speedX
        ballY += speedY

        // Sprawdzenie kolizji z krawędziami ekranu
        if (ballX + ballRadius > screenWidth || ballX - ballRadius < -screenWidth) {
            speedX = -speedX // Zmiana kierunku ruchu w osi X
        }

        // Rysowanie piłki
        drawBall(gl, ballX, ballY, ballRadius)
    }

    private fun drawBall(gl: GL10?, x: Float, y: Float, radius: Float) {
        val numSegments = 100
        val vertices = FloatArray(numSegments * 3)

        for (i in 0 until numSegments) {
            val angle = 2.0 * Math.PI * i / numSegments
            vertices[i * 3] = (x + radius * cos(angle)).toFloat()
            vertices[i * 3 + 1] = (y + radius * sin(angle)).toFloat()
            vertices[i * 3 + 2] = 0f
        }

        val buffer: ByteBuffer = ByteBuffer.allocateDirect(vertices.size * 4)
        buffer.order(ByteOrder.nativeOrder())
        val verticesBuffer: FloatBuffer = buffer.asFloatBuffer()
        verticesBuffer.put(vertices)
        verticesBuffer.position(0)

        gl?.glColor4f(0.0f, 0.0f, 1.0f, 1.0f)
        gl?.glEnableClientState(GL10.GL_VERTEX_ARRAY)
        gl?.glVertexPointer(3, GL10.GL_FLOAT, 0, verticesBuffer)
        gl?.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0, numSegments)
        gl?.glDisableClientState(GL10.GL_VERTEX_ARRAY)
    }
}