//1
import ddf.minim.*;
import ddf.minim.signals.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;

import processing.opengl.*;

ArrayList triparts;

//declare arraylist
ArrayList particles;
//2
Minim minim;
AudioInput input;

float a, a2;


void setup()
{
    size(1000, 1000, OPENGL);
    //construct arraylist
    particles = new ArrayList();
    triparts = new ArrayList();

    minim = new Minim(this);
    //512 works as an array of ampllitude
    input = minim.getLineIn(Minim.MONO, 360);
}

void draw()
{

    background(67);
    a = abs(input.left.get(0))*20;
    if (a > a2) {
        a2 = a;
    }
    a2*=.3;

    if (a2 > .5) {
        for (int i = 0; i<30; i++)
        {
            particles.add(new Particle());
        }
    }
    //use parts.size to get everything in arraylist
    for (int i = particles.size()-1;i >= 0; i--)
    {
        //pull the particle out of the arraylist - cast it as type "Particle"
        Particle p = (Particle) particles.get(i);
        p.update();
        p.display();
        p.bounce();
        // to get rid of excess particles
        // if (p.alf < 1) {
        //  parts.remove(i);
        //}
    }


    if (a2 > .9) {
        for (int i = 0; i<1; i++)
        {
            triparts.add(new Peep());
        }
    }
    for (int i = 0; i < triparts.size(); i++)
    {
        //pull the particle out of the arraylist - cast it as type "Particle"
        Peep tri = (Peep) triparts.get(i);
        tri.display();
        tri.update();
        // to get rid of excess particles
        // if (p.alf < 1) {
        //  parts.remove(i);
        //}
    }



    noFill();
    stroke(255, 100);
}
class Particle
{
    float x, y, vx, vy, angle, drag, grav;
    float alf;


    float inc = 0.0;



    Particle()
    {
        x = random(width);
        y = height/4;
        angle = random(0, 2*PI);
        vx = sin(angle)*a2;
        vy = cos(angle)*a2;
        drag = random(.93, .98);
        //to change how it falls
        grav = .05;
        alf = 150;
    }



    void update()
    {
        alf-=.5;
        x+=vx;
        y+=vy;
        //slow the velocity
        vx*=drag;
        vy*=drag;
        ///add on the gravity to the velocity of Y
        vy+=grav;
    }

    void display() {


        stroke(255);
        pushMatrix();
        translate(x, y);
        ellipse(0, 0, 10, 10);
        popMatrix();
    }

    void bounce() {
        if ((y > height)) {
            stroke(0);
            vy = (vy * -2) *(random(2, 3));
            inc += 0.01;
        }
    }


    void checkBounce(Peep tri)
    {
        if (circleLineIntersect(tri.x1, tri.y1, tri.x2, tri.y2, particleX, particleY, particleRadius) == true) {
            p.vy = (vy * -2) *(random(2, 3));
            p.inc += 0.01;
        }
        else {
            fill(255);
        }
    }

    boolean circleLineIntersect(float x1, float y1, float x2, float y2, float cx, float cy, float cr ) {
        float dx = x2 - x1;
        float dy = y2 - y1;
        float a = dx * dx + dy * dy;
        float b = 2 * (dx * (x1 - cx) + dy * (y1 - cy));
        float c = cx * cx + cy * cy;
        c += x1 * x1 + y1 * y1;
        c -= 2 * (cx * x1 + cy * y1);
        c -= cr * cr;
        float bb4ac = b * b - 4 * a * c;

        if (bb4ac < 0) {  // Not intersecting
            return false;
        }
        else {

            float mu = (-b + sqrt( b*b - 4*a*c )) / (2*a);
            float ix1 = x1 + mu*(dx);
            float iy1 = y1 + mu*(dy);

            mu = (-b - sqrt(b*b - 4*a*c )) / (2*a);
            float ix2 = x1 + mu*(dx);
            float iy2 = y1 + mu*(dy);

            // The intersection points
            //ellipse(ix1, iy1, 10, 10);
            //ellipse(ix2, iy2, 10, 10);

            float testX;
            float testY;
            // Figure out which point is closer to the circle
            if (dist(x1, y1, cx, cy) < dist(x2, y2, cx, cy)) {
                testX = x2;
                testY = y2;
            } 
            else {
                testX = x1;
                testY = y1;
            }

            if (dist(testX, testY, ix1, iy1) < dist(x1, y1, x2, y2) || dist(testX, testY, ix2, iy2) < dist(x1, y1, x2, y2)) {
                return true;
            } 
            else {
                return false;
            }
        }
    }
}


class Peep
{
    float x, y, z;
    float alf = 100;

    float x1, y1, x2, y2, ty2;

    Peep()
    {
        x = random(0, width);
        y = 0;
    }

    void update()
    {
        alf-=.5;
    }


    void display()
    {
        //triangle coordinate
        x1 = 0;
        y1 = (x+50);
        x2 = (x+75);
        y2 = (x+100);
        ty2 = (x+200);

        noStroke();
        fill(0, 0, 0, alf);


        triangle(x1, y1, x2, y2, (x+100), ty2);
    }
}