#include <iostream>
#include <cmath>
#include "draw/sdlwrapper.h"

//#include <stdio.h>


using namespace std;

void drawSaw(int startY, int toothSize, int nTeeth)
{
    for(int i = 0; i < nTeeth; ++i)
    {
        sdlw::drawLine(2*i*toothSize,0+startY,(2*i+1)*toothSize,toothSize+startY);    
        sdlw::drawLine((2*i+1)*toothSize,toothSize+startY,2*(i+1)*toothSize,0+startY);        
    }

    sdlw::drawLine(0,0+startY,2*nTeeth*toothSize,0+startY);

}

void drawEars(int startX, int startY, int toothSize, int interval, int nTeeth)
{
    sdlw::drawLine(startX,                  startY,             startX + toothSize,     startY - 2*toothSize);
    sdlw::drawLine(startX + toothSize,      startY - 2*toothSize, startX + 2*toothSize,   startY);
    
    for(int i = 1; i < nTeeth; ++i)
    {
        sdlw::drawLine(startX + 2*i*toothSize + (i-1)*interval,  startY,    startX + 2*i*toothSize + i*interval,  startY);

        sdlw::drawLine(startX + 2*i*toothSize + i*interval,      startY,             startX + (2*i+1)*toothSize + i*interval,   startY - 2*toothSize);
        sdlw::drawLine(startX + (2*i+1)*toothSize + i*interval,  startY - 2*toothSize, startX + 2*(i+1)*toothSize + i*interval,   startY);
    }
}

void drawNose(double x, double y, double radius)
{
    int n = 32;
    x = x - radius;

    for (int side = 0; side < n/4; side++)
    {
        sdlw::drawLine (radius*cos(side*2.0*M_PI/n)+x,
        radius*sin(side*2.0*M_PI/n)+y,
        radius*cos((side+1)*2.0*M_PI/n)+x,
        radius*sin((side+1)*2.0*M_PI/n)+y);
    }

    x = x + 2*radius;
    for (int side = 0; side < n/4; side++)
    {
        sdlw::drawLine (x - radius*cos(side*2.0*M_PI/n),
        radius*sin(side*2.0*M_PI/n)+y,
        x - radius*cos((side+1)*2.0*M_PI/n),
        radius*sin((side+1)*2.0*M_PI/n)+y);
    }
}

void drawTail(double x, double y, double radius)
{
    int n = 100;
    for (int side = n/4; side < 3*n/4; side++)
    {
        sdlw::drawLine (radius*cos(side*2.0*M_PI/n)+x,
        radius*sin(side*2.0*M_PI/n)+y,
        radius*cos((side+1)*2.0*M_PI/n)+x,
        radius*sin((side+1)*2.0*M_PI/n)+y);
    }
}

void polygonLowerHalf (int n, double x, double y, double radius)
{
    for (int side = 0; side < n/2; side++)
    {
        sdlw::drawLine (radius*cos(side*2.0*M_PI/n)+x,
        radius*sin(side*2.0*M_PI/n)+y,
        radius*cos((side+1)*2.0*M_PI/n)+x,
        radius*sin((side+1)*2.0*M_PI/n)+y);
    }
}

void polygonLeftHalf (int n, double x, double y, double radius, double maxHeight)
{
    double sinA = maxHeight/radius;
    double a = asin(sinA);
    double pi = 3.14159265358979323846;

    for (int side = (n/2)*(pi-a)/pi; side < (n/2)*(pi+a)/pi; side++) 
    {
        sdlw::drawLine (radius*cos(side*2.0*M_PI/n)+x,
        radius*sin(side*2.0*M_PI/n)+y,
        radius*cos((side+1)*2.0*M_PI/n)+x,
        radius*sin((side+1)*2.0*M_PI/n)+y);
    }
}

void polygonRightHalf (int n, double x, double y, double radius, double maxHeight)
{
    double sinA = maxHeight/radius;
    double a = asin(sinA);
    double pi = 3.14159265358979323846;

    for (int side = (n/2)*(pi-a)/pi; side < (n/2)*(pi+a)/pi; side++)
    {
        sdlw::drawLine (x - radius*cos(side*2.0*M_PI/n),
        radius*sin(side*2.0*M_PI/n)+y,
        x - radius*cos((side+1)*2.0*M_PI/n),
        radius*sin((side+1)*2.0*M_PI/n)+y);
    }
}

void drawHair(double startX, double startY, double radius, int interval, int nTeeth)
{
    int polygonN = 100;
    polygonLowerHalf(polygonN, startX, startY, radius);
    
    for(int i = 1; i < nTeeth; ++i)
    {
        sdlw::drawLine(startX + (2*i-1)*radius + (i-1)*interval,  startY,    startX + (2*i-1)*radius + i*interval,   startY);

        polygonLowerHalf(polygonN, startX + 2*i*radius + i*interval, startY, radius);

        //sdlw::drawLine(startX + 3*i*toothSize,      startY,             startX + (3*i+1)*toothSize,   startY - toothSize);
        //sdlw::drawLine(startX + (3*i+1)*toothSize,  startY - toothSize, startX + (3*i+2)*toothSize,   startY);
    }
}

void drawSinus(int x0, int y0, double freq, double ampl)
{
    double prec = 0.2;
    for(int i = 0; i < 100; ++i)
    {
        sdlw::drawLine(x0+i*3,y0+100+sin(i*prec*freq)*ampl,
                       x0+(i+1)*3,y0+100+sin((i+1)*prec*freq)*ampl);
    }
}


int main(int argv, char** args)
{
    sdlw::setColor(255,255,255);
    
    int centerX = 350, centerY = 300;
    int heightHalf = 120, widthHalf = 400;

    // Back
    int backX = centerX - widthHalf/2, backY = centerY - heightHalf, backLength = 3*widthHalf/4;
    sdlw::drawLine(backX, backY, backX + backLength, backY);

    double earsX = backX + backLength, earsY = backY, earsHalfSize = widthHalf/24, earsInterval = 2*earsHalfSize, earsCount = 2;
    drawEars(earsX, earsY, earsHalfSize, earsInterval, earsCount);

    double hairHalfSize = earsInterval/10, hairInterval = earsInterval/5;
    double hairX = earsX + 2*earsHalfSize + hairHalfSize, hairY = earsY, hairCount = 3;
    drawHair(hairX, hairY, hairHalfSize, hairInterval, hairCount);

    
    double bellyLength = backLength + 4*earsHalfSize + earsInterval;
    
    double legsHalfSize = bellyLength/32, legsInterval = legsHalfSize*8;
    double legsX = backX + legsHalfSize, legsY = backY + 2*heightHalf, legsCount = 4;
    drawHair(legsX, legsY, legsHalfSize, legsInterval, legsCount);

    double spotsHalfSize = widthHalf/10, spotsInterval = spotsHalfSize;
    double spotsX = backX + spotsHalfSize, spotsY = backY, spotsCount = 2;
    drawHair(spotsX, spotsY, spotsHalfSize, spotsInterval, spotsCount);

    double buttRadius = sqrt(heightHalf*heightHalf + widthHalf*widthHalf/4);
    polygonLeftHalf(100, centerX, centerY, buttRadius, heightHalf);
    polygonRightHalf(100, centerX, centerY, buttRadius, heightHalf);

    double eyesY = centerY - heightHalf/2, eyesRadius = earsHalfSize/2;
    double eyesLX = earsX + earsHalfSize;
    double eyesRX = earsX + 3*earsHalfSize + earsInterval;
    sdlw::drawFillCircle(eyesLX, eyesY, eyesRadius);
    sdlw::drawFillCircle(eyesRX, eyesY, eyesRadius);  

    drawNose(earsX + 2*earsHalfSize + earsInterval/2, eyesY, earsHalfSize/2);  

    double bottomWhiskerY = eyesY + eyesRadius;
    double bottomWhiskerX = centerX + sqrt(buttRadius*buttRadius - (centerY -  bottomWhiskerY)*(centerY -  bottomWhiskerY));
    sdlw::drawLine(bottomWhiskerX, bottomWhiskerY, bottomWhiskerX +20, bottomWhiskerY +5);
    sdlw::drawLine(eyesLX - (bottomWhiskerX - eyesRX), bottomWhiskerY, eyesLX - (bottomWhiskerX - eyesRX) -20, bottomWhiskerY +5);    

    double topWhiskerY = eyesY - eyesRadius;
    double topWhiskerX = centerX + sqrt(buttRadius*buttRadius - (centerY -  topWhiskerY)*(centerY -  topWhiskerY));
    sdlw::drawLine(topWhiskerX, topWhiskerY, topWhiskerX +20, topWhiskerY - 10);
    sdlw::drawLine(eyesLX - (topWhiskerX - eyesRX), topWhiskerY, eyesLX - (topWhiskerX - eyesRX) -20, topWhiskerY - 10);

    drawTail(2*centerX - bottomWhiskerX, bottomWhiskerY, 20);
    
    //buttRadius*buttRadius - (eyesY )
    
    //drawSaw(100,20,10);
    //drawSaw(170,40,5);

    //drawSinus(0,100,1,30);
    //drawSinus(0,50,3,30);

    sdlw::updateGraphics();
    std::cin.get();
    
    return 0;
}