// ohjelma.hpp
namespace ohjelma {
    // Funktiot ajan hakemiseen (ja laskurin nollaamiseen) sekä odottamiseen.
    float sekunnit(bool nollaa = false);
    void odota();
}

// ohjelma.cpp
// Kertoo nollauksesta kuluneiden sekuntien määrän.
float ohjelma::sekunnit(bool nollaa) {
    static Uint32 alku;
    Uint32 nyt = SDL_GetTicks();
    if (nollaa) {
        alku = nyt;
    }
    return (nyt - alku) / 1000.0f;
}

// Odottaa lyhyen ajan.
void ohjelma::odota() {
    SDL_Delay(1);
}

// peli.hpp
#ifndef _PELI_HPP
#define _PELI_HPP

namespace peli {
    // Pelin pääfunktio; palauttaa pistemäärän.
    int aja();

    // Pelialueen kulmien koordinaatit ovat kokonaislukuja.
    struct alue {
        int x0, y0, x1, y1;
    };
    // Omenalla on x- ja y-koordinaatit.
    struct omena {
        float x, y;
    };
    // Mato on hieman mutkikkaampi.
    struct mato {
        // Mato muodostuu jaokkeista. Jaokkeella on todellinen sijainti
        // (x, y) ja mateluliikettä varten kiinteä sijainti (x0, y0).
        // Lisäksi jaoke sisältää osoittimen seuraavaan ja edelliseen
        // jaokkeeseen; rakenne on hienolta nimeltään linkitetty lista.
        struct jaoke {
            float x, y;
            float x0, y0;
            jaoke *nenampi, *hannampi;
        };
        // Mato itse sisältää osoittimet alkuun ja loppuun.
        jaoke *nena, *hanta;

        // Madolla on kulkusuunta ja mateluliikkeellä tietty vaihe.
        float suunta, vaihe;
    };
}

#endif

// peli.cpp; paikallisia vakioita
namespace peli {
    // Pienin aikamäärä, jonka kello etenee. Liian lyhyt väli vaatii paljon
    // tehoa. Matopelissä 0.02 (eli 2 / 100) sekuntia on tarpeeksi lyhyt.
    static const float ajan_muutos = 0.02;

    // Pelikentän rajat (x0, y0, x1, y1).
    static const alue pelialue = {-8, -6, 8, 6};
}

// ohjelma.hpp
#include "peli.hpp"

namespace ohjelma {
    // Funktio pelitilanteen piirtoon. Olennaisia tietoja funktiossa ovat
    // pelialueen rajat, mato ja omena.
    void piirra_peli(peli::alue const& alue, peli::mato const& mato, peli::omena const& omena);
}

// ohjelma.cpp
// Piirtää pelin.
void ohjelma::piirra_peli(peli::alue const& alue, peli::mato const& mato, peli::omena const& omena) {
    piirra_kuva(kuvat::tausta_peli, 0, 0);

    // Määritellään yksikkö madon jaokkeen koon mukaan.
    const float yksikko_x = kuvat::matopallo->w;
    const float yksikko_y = kuvat::matopallo->h;

    // Lasketaan lisättävä pikselimäärä, jotta pelialue tulee ruudun keskelle.
    // (Oletetaan, että alue mahtuu kerralla ruudulle!)
    const float keski_x = ruutu->w / 2 - yksikko_x * (alue.x0 + alue.x1) / 2;
    const float keski_y = ruutu->h / 2 - yksikko_y * (alue.y0 + alue.y1) / 2;

    // Piirretään pelialueen reunat.
    for (int i = alue.x0 - 1; i <= alue.x1; ++i) {
        piirra_kuva(kuvat::reunapala, keski_x + yksikko_x * i, keski_y + yksikko_y * (alue.y0 - 1));
        piirra_kuva(kuvat::reunapala, keski_x + yksikko_x * i, keski_y + yksikko_y * alue.y1);
    }
    for (int i = alue.y0; i < alue.y1; ++i) {
        piirra_kuva(kuvat::reunapala, keski_x + yksikko_x * (alue.x0 - 1), keski_y + yksikko_y * i);
        piirra_kuva(kuvat::reunapala, keski_x + yksikko_x * alue.x1, keski_y + yksikko_y * i);
    }

    // Piirretään mato hännästä nenään.
    for (peli::mato::jaoke *j = mato.hanta; j != 0; j = j->nenampi) {
        piirra_kuva(kuvat::matopallo, keski_x + yksikko_x * j->x, keski_y + yksikko_y * j->y, true);
    }

    // Piirretään omena.
    piirra_kuva(kuvat::omena, keski_x + yksikko_x * omena.x, keski_y + yksikko_y * omena.y, true);

    SDL_Flip(ruutu);
}

// peli.cpp; paikallisia funktioita
namespace peli {
    // Funktiot madon luontiin, kasvatukseen ja tuhoamiseen.
    static mato uusi_mato();
    static void jatka_matoa(mato& m);
    static void tuhoa_mato(mato& m);

    // Funktio omenan arpomiseen; parametrina on mato, jottei luoda omenaa
    // madon päälle vaan jonnekin sivummalle.
    static omena arvo_omena(mato const& m);

    // Funktiot madon liikuttamiseen ja törmäystarkistuksiin.
    static void liikuta(mato& m, bool oikealle, bool vasemmalle);
    static bool osuu_omenaan(mato const& m, omena const& o);
    static bool tormaa(mato const& m);
}

// Liikuttaa matoa.
void peli::liikuta(mato& m, bool oikealle, bool vasemmalle) {
    // PUUTTUU!
}

// Arpoo omenan.
peli::omena peli::arvo_omena(const mato& m) {
    peli::omena o = {3, 3};
    // PUUTTUU!
    return o;
}

// Tarkistaa osumisen omenaan.
bool peli::osuu_omenaan(mato const& m, omena const& o) {
    // PUUTTUU!
    return false;
}

// Tarkistaa madon törmäyksen itseensä ja reunoihin.
bool peli::tormaa(mato const& m) {
    // PUUTTUU!
    return false;
}

// Luo madon.
peli::mato peli::uusi_mato() {
    mato m;
    // Suunta ja vaihe alustetaan nollaan.
    m.suunta = m.vaihe = 0;

    // Nenä ja häntä ovat alkuun sama jaoke.
    // Kummastakaan suunnasta ei pääse pidemmälle.
    // Jaoke sijaitsee maailman keskellä.
    m.nena = m.hanta = new mato::jaoke;
    m.nena->nenampi = m.hanta->hannampi = 0;
    m.nena->x = m.nena->x0 = (pelialue.x0 + pelialue.x1) / 2;
    m.nena->y = m.nena->y0 = (pelialue.y0 + pelialue.y1) / 2;

    // Lisätään matoon jatkofunktiolla pari jaoketta.
    jatka_matoa(m);
    jatka_matoa(m);
    return m;
}

// Lisää madon etupäähän palan.
void peli::jatka_matoa(mato& m) {
    mato::jaoke *j = new mato::jaoke;
    // Uusi jaoke on ensimmäisenä eli vanhasta nenästä vielä nenään päin.
    // Kopioidaan uuteen jaokkeeseen nenän tiedot ja korjataan osoittimet.
    *j = *m.nena;
    j->hannampi = m.nena;
    m.nena->nenampi = j;
    m.nena = j;
}

// Tuhoaa madon.
void peli::tuhoa_mato(mato& m) {
    // Poistetaan madosta jaokkeita, kunnes nenä ja häntä ovat sama jaoke.
    while (m.nena != m.hanta) {
        // Siirretään nenäosoitinta, tuhotaan vanha jaoke.
        m.nena = m.nena->hannampi;
        delete m.nena->nenampi;
        m.nena->nenampi = 0;
    }
    // Tuhotaan viimeinen jaoke.
    delete m.nena;
    m.nena = m.hanta = 0;
}

#include <cstdlib>
#include <ctime>

// Pelin pääfunktio.
int peli::aja() {
    std::clog << "peli::aja()" << std::endl;

    // Alustetaan satunnaislukugeneraattori ajan perusteella.
    // Tätä tarvitaan myöhemmin omenoiden arpomiseen.
    std::srand(std::time(0));

    // Luodaan mato ja omena.
    mato m = uusi_mato();
    omena o = arvo_omena(m);

    int tulos = 0;
    bool loppu = false, piirretty = false;

    // Nollataan kello.
    float pelin_kello = ohjelma::sekunnit(true);
    while (!loppu) {
        // Esc-nappi lopettaa pelin.
        if (ohjelma::lue_nappi(ohjelma::NAPPI_ESCAPE)) {
            break;
        }
        // Luetaan muidenkin olennaisten nappien tilat.
        const bool nappi_oikea = ohjelma::lue_nappi(ohjelma::NAPPI_OIKEA);
        const bool nappi_vasen = ohjelma::lue_nappi(ohjelma::NAPPI_VASEN);

        // Nopeuden säilyttämiseksi toistetaan madon liikutusta
        // pienissä erissä, kunnes pelin kello saavuttaa oikean ajan.
        while (pelin_kello + ajan_muutos <= ohjelma::sekunnit()) {
            // Joka kerta liikutetaan matoa ja tehdään keskeiset
            // tarkistukset: törmäys lopettaa pelin, omenan syönti
            // kasvattaa matoa ja tulosta ja tuottaa uuden omenan.
            liikuta(m, nappi_oikea, nappi_vasen);
            if (tormaa(m)) {
                loppu = true;
                break;
            }
            if (osuu_omenaan(m, o)) {
                ++tulos;
                jatka_matoa(m);
                o = arvo_omena(m);
            }
            pelin_kello += ajan_muutos;

            // Merkitään, että nykytilaa ei ole piirretty.
            piirretty = false;
        }
        if (piirretty) {
            // Jos tilanne ei ole muuttunut, turha sitä on piirtää.
            // Odotetaan hetki ja katsotaan sitten taas kelloa.
            ohjelma::odota();
        } else {
            // Muuttunut tilanne pitää piirtää.
            ohjelma::piirra_peli(pelialue, m, o);
            piirretty = false;
        }
    }

    // Näytetään lopputilannetta, kunnes käyttäjä painaa nappia.
    ohjelma::tyhjenna_syote();
    if (loppu) {
        ohjelma::odota_nappi();
    }

    // Vapautetaan madolle varattu muisti.
    tuhoa_mato(m);

    std::clog << "peli::aja(): tulos = " << tulos << std::endl;
    return tulos;
}