import traer.physics.*;

color timeOutColor = color(255, 0, 0, 200);
color normalColor = color(0, 0, 0, 200);
ParticleSystem physics;

SevenSegments ss;

SevenSegments ss1, ss2;
SevenSegments sm1, sm2;
SevenSegments sh1, sh2;
SevenSegments scdh1, scdh2;
SevenSegments scdm1, scdm2;


int s1, pS1= -1;
int s2, pS2 = -1;

int m1, pM1 = -1;
int m2, pM2 = -1;

int h1, pH1 = -1;
int h2, pH2 = -1;

int cdm1 = 6;
int cdm2 = 0;
int cdh1 = 0;
int cdh2 = 1;

int x = 0;

float rot  = 0;
boolean stop = false;
float lastMove = -1;
int current = 4;

int lastPressedTime = 0;
void setup()
{
    size( 350, 300 );
    smooth();
    fill( 0 );
    framerate( 15 );
    ellipseMode( CENTER );


    int dist = (int)((width-100)/5.0);
    int segWidth = (int)(4.0*dist/5.0);
    int hangLength = height-2*segWidth-150;
    if (hangLength < 40) {
        hangLength = 40;
    }

    physics = new ParticleSystem( 1.0, 0.05 );

    scdh1 = new SevenSegments(physics, 50, hangLength, segWidth, hangLength);        
    scdh2 = new SevenSegments(physics, 50+dist, hangLength, segWidth, hangLength);        
    scdm1 = new SevenSegments(physics, 50+dist*3, hangLength, segWidth, hangLength);        
    scdm2 = new SevenSegments(physics, 50+dist*4, hangLength, segWidth, hangLength);   

    sh1 = new SevenSegments(physics, (width-25*8)/2, height-20*2-50, 20);   
    sh2 = new SevenSegments(physics, (width-25*8)/2+25, height-20*2-50, 20);      

    sm1 = new SevenSegments(physics, (width-25*8)/2+75, height-20*2-50, 20);        
    sm2 = new SevenSegments(physics, (width-25*8)/2+100, height-20*2-50, 20);    

    ss1 = new SevenSegments(physics, (width-25*8)/2+150, height-20*2-50, 20);        
    ss2 = new SevenSegments(physics, (width-25*8)/2+175, height-20*2-50, 20);        


    // corner[0].setVelocity(1, 0, 0);
    //center.setVelocity(1, 1, 0);
    // corner[0].moveTo(50, 10, 0);
}

void draw()
{

    sh1.move();
    sh2.move();
    sm1.move();
    sm2.move();
    ss1.move();
    ss2.move();
    scdh1.move();
    scdh2.move();
    scdm1.move();
    scdm2.move();


    scdm1.setColor(normalColor);
    scdm2.setColor(normalColor);
    scdh1.setColor(normalColor);
    scdh2.setColor(normalColor);
    switch(current) {
    case 0: 
        scdh1.setColor(200); 
        break;
    case 1: 
        scdh2.setColor(200); 
        break;
    case 2: 
        scdm1.setColor(200); 
        break;
    case 3: 
        scdm2.setColor(200); 
        break;
    }
    if (stop) {
        scdm1.setColor(timeOutColor);
        scdm2.setColor(timeOutColor);
        scdh1.setColor(timeOutColor);
        scdh2.setColor(timeOutColor);    
    }
    /*  if (millis()-lastMove > 5000) {
     lastMove = millis();
     }*/

    background( 255 );
    int s = second();
    s1 = s/10;
    s2 = s%10;
    if (s1 != pS1) {
        pS1 = s1;
        ss1.setDigit(s1);
    }
    if ( s2 != pS2) {
        pS2 = s2;
        ss2.setDigit(s2);
    }
    int m = minute();
    m1 = m/10;
    m2 = m%10;
    if (m1 != pM1) {
        pM1 = m1;
        sm1.setDigit(m1);
    }  
    if (m2 != pM2) {
        if (!stop) {
            cdm2--;
            if (cdm2 < 0) {
                cdm2 = 9;
                cdm1--;
                if (cdm1 < 0) {
                    cdm1 = 5;
                    cdh2--;
                    if (cdh2 < 0) {
                        cdh2 = 9;
                        cdh1--;
                        if (cdh1 < 0) {
                            cdh1 = 0;                        
                        }
                    }
                }
            }
            if (cdm1 == 0 && cdm2 == 0 && cdh1 == 0 && cdh2 == 0) {
                stop = true;
                scdm1.setColor(timeOutColor);
                scdm2.setColor(timeOutColor);
                scdh1.setColor(timeOutColor);
                scdh2.setColor(timeOutColor);
            }
        }
        scdm1.setDigit(cdm1);
        scdm2.setDigit(cdm2);
        scdh1.setDigit(cdh1);
        scdh2.setDigit(cdh2);    
        pM2 = m2;
        sm2.setDigit(m2);
    }  
    int h = hour();
    h1 = h/10;
    h2 = h%10;
    if (h1 != pH1) {
        pH1 = h1;
        sh1.setDigit(h1);
    }  
    if (h2 != pH2) {
        pH2 = h2;
        sh2.setDigit(h2);
    }  

    // println(h1 + "" + h2 + ":" + m1 + "" + m2 + ":" + s1 + "" + s2);



    ss1.draw();
    ss2.draw();
    sm1.draw();
    sm2.draw();
    sh1.draw();
    sh2.draw();  
    scdh1.draw();
    scdh2.draw();
    scdm1.draw();
    scdm2.draw();
    physics.advanceTime( 1.0 );
}

void mousePressed()
{
    x++;
    if (x > 9) {
        x = 0;
    }
    //  ss.setDigit(x);
    float g = random(-1, 5);
    println("Gravity: " + (mouseY-height/2)*5.0/(height/2.0));
    physics.setGravity(0, (mouseY-height/2)*5.0/(height/2.0), 0);
}

void mouseDragged()
{
    // p.moveTo( mouseX, mouseY, 0 );
    // p.setVelocity( (mouseX - pmouseX), (mouseY - pmouseY), 0 );
}

void keyPressed() {
    if ( (millis()-lastPressedTime) > 5000) {
        current = 4;        
    }
    lastPressedTime = millis();

    if (keyCode == LEFT) {
        rot += 0.05;
    } 
    else if (keyCode == RIGHT) {
        rot -= 0.05;
    } 
    else if (key >= '0' && key <= '9') {
        switch(current) {
        case 0: 
            cdh1 = key - '0'; 
            break;
        case 1: 
            cdh2 = key-'0'; 
            break;
        case 2: 
            cdm1 = key-'0'; 
            break;
        case 3: 
            cdm2 = key-'0'; 
            break;
        }
        current ++;
        current = current % 5;
        scdm1.setDigit(cdm1);
        scdm2.setDigit(cdm2);
        scdh1.setDigit(cdh1);
        scdh2.setDigit(cdh2); 
    }
    stop = false;

}

public class SevenSegments {

    private  int SEG_LEN = 40;
    private  int HANG_LEN = 50;
    private static final int LINE_WEIGHT = 1;
    private static final int POINT_WEIGHT = 1;

    private color fillColor = color(0, 0, 0);
    Particle hang;
    Spring sLeft, sRight;
    Particle dot[] = new Particle[14];
    Spring segment[] = new Spring[23];

    int segs[][] = {
        {
            0, 1, 7, 6                                        }
        ,
        {
            1, 2, 8, 7                                        }
        ,
        {
            2, 3, 12, 11                                        }
        ,
        {
            3, 4, 13, 12                                        }
        ,
        {
            4, 5, 10, 13                                        }
        ,
        {
            0, 6, 9, 5                                        }
        ,
        {
            9, 8, 2, 11, 10, 5                                        }
    };
    boolean lit[][] = {
        {
            true, true, true, true, true, true, false                                            }
        ,
        {
            false, true, true, false, false, false, false                                            }
        ,
        {
            true, true, false, true, true, false, true                                            }
        ,
        {
            true, true, true, true, false, false, true                                            }
        ,
        {
            false, true, true, false, false, true, true                                            }
        ,
        {
            true, false, true, true, false, true, true                                            }
        ,
        {
            true, false, true, true, true, true, true                                            }
        ,
        {
            true, true, true, false, false, false, false                                            }
        ,
        {
            true, true, true, true, true, true, true                                            }
        ,
        {
            true, true, true, false, false, true, true                                            }
    };
    int digit = 8;

    public SevenSegments(ParticleSystem ps, int x, int y) {
        this(ps, x, y, 40);
    }
    public SevenSegments(ParticleSystem ps, int x, int y, int seg_len) {
        this(ps, x, y, seg_len, 50);
    }    
    public SevenSegments(ParticleSystem ps, int x, int y, int seg_len, int hang_len) {
        this.SEG_LEN = seg_len;
        this.HANG_LEN = hang_len;
        hang = ps.makeParticle(1.0, x+SEG_LEN/2.0, y-HANG_LEN, 0);
        hang.makeFixed();

        dot[0] = ps.makeParticle(1.0, x, y, 0);
        dot[1] = ps.makeParticle(1.0, x+SEG_LEN, y, 0);
        dot[2] = ps.makeParticle(1.0, x+SEG_LEN, y+SEG_LEN, 0);
        dot[3] = ps.makeParticle(1.0, x+SEG_LEN, y+SEG_LEN*2, 0);
        dot[4] = ps.makeParticle(1.0, x, y+SEG_LEN*2, 0);
        dot[5] = ps.makeParticle(1.0, x, y+SEG_LEN, 0);
        dot[6] = ps.makeParticle(1.0, x+SEG_LEN/5.0, y+SEG_LEN/5.0, 0);
        dot[7] = ps.makeParticle(1.0, x+SEG_LEN-SEG_LEN/5.0, y+SEG_LEN/5.0, 0);
        dot[8] = ps.makeParticle(1.0, x+SEG_LEN-SEG_LEN/5.0, y+SEG_LEN-SEG_LEN/5.0, 0);
        dot[9] = ps.makeParticle(1.0, x+SEG_LEN/5.0, y+SEG_LEN-SEG_LEN/5.0, 0);
        dot[10] = ps.makeParticle(1.0, x+SEG_LEN/5.0, y+SEG_LEN+SEG_LEN/5.0, 0);    
        dot[11] = ps.makeParticle(1.0, x+SEG_LEN-SEG_LEN/5.0, y+SEG_LEN+SEG_LEN/5.0, 0);
        dot[12] = ps.makeParticle(1.0, x+SEG_LEN-SEG_LEN/5.0, y+SEG_LEN*2.0-SEG_LEN/5.0, 0);
        dot[13] = ps.makeParticle(1.0, x+SEG_LEN/5.0, y+SEG_LEN*2.0-SEG_LEN/5.0, 0);

        sLeft = ps.makeSpring(hang, dot[0], 1.0, 0.1, HANG_LEN);
        sRight = ps.makeSpring(hang, dot[1], 1.0, 0.1, HANG_LEN);


        segment[0] = ps.makeSpring(dot[0], dot[1], 1.0, 0.1, SEG_LEN);
        segment[1] = ps.makeSpring(dot[1], dot[2], 1.0, 0.1, SEG_LEN);
        segment[2] = ps.makeSpring(dot[2], dot[3], 1.0, 0.1, SEG_LEN);
        segment[3] = ps.makeSpring(dot[3], dot[4], 1.0, 0.1, SEG_LEN);
        segment[4] = ps.makeSpring(dot[4], dot[5], 1.0, 0.1, SEG_LEN);
        segment[5] = ps.makeSpring(dot[5], dot[0], 1.0, 0.1, SEG_LEN);
        segment[6] = ps.makeSpring(dot[6], dot[7], 1.0, 0.1, dist(dot[6], dot[7]));      
        segment[7] = ps.makeSpring(dot[7], dot[8], 1.0, 0.1, dist(dot[7], dot[8])); 
        segment[8] = ps.makeSpring(dot[8], dot[9], 1.0, 0.1, dist(dot[8], dot[9])); 
        segment[9] = ps.makeSpring(dot[9], dot[6], 1.0, 0.1, dist(dot[9], dot[6])); 
        segment[10] = ps.makeSpring(dot[10], dot[11], 1.0, 0.1, dist(dot[10], dot[11])); 
        segment[11] = ps.makeSpring(dot[11], dot[12], 1.0, 0.1, dist(dot[11], dot[12])); 
        segment[12] = ps.makeSpring(dot[12], dot[13], 1.0, 0.1, dist(dot[12], dot[13])); 
        segment[13] = ps.makeSpring(dot[13], dot[10], 1.0, 0.1, dist(dot[13], dot[10])); 
        segment[14] = ps.makeSpring(dot[0], dot[6], 1.0, 0.1, dist(dot[0], dot[6])); 
        segment[15] = ps.makeSpring(dot[1], dot[7], 1.0, 0.1, dist(dot[1], dot[7])); 
        segment[16] = ps.makeSpring(dot[2], dot[8], 1.0, 0.1, dist(dot[2], dot[8])); 
        segment[17] = ps.makeSpring(dot[2], dot[11], 1.0, 0.1, dist(dot[2], dot[11])); 
        segment[18] = ps.makeSpring(dot[3], dot[12], 1.0, 0.1, dist(dot[3], dot[12])); 
        segment[19] = ps.makeSpring(dot[4], dot[13], 1.0, 0.1, dist(dot[4], dot[13])); 
        segment[20] = ps.makeSpring(dot[5], dot[10], 1.0, 0.1, dist(dot[5], dot[10])); 
        segment[21] = ps.makeSpring(dot[5], dot[9], 1.0, 0.1, dist(dot[5], dot[9])); 
        segment[22] = ps.makeSpring(dot[5], dot[2], 1.0, 0.1, dist(dot[5], dot[2])); 
        for (int i = 0; i < segment.length; i++) {
            println("i: "+ i + " length: " + segment[i].length());
        }
    }

    public void setDigit(int digit) {
        this.digit = digit;
        for (int i = 0; i < dot.length; i++) {
            dot[i].moveBy(random(5), -10, 0);
        }
    }

    public void move() {
        float xv = random(-0.3, 0.3);
        float yv = random(-0.1, 0.1);
        for (int i = 0; i < dot.length; i++) {
            dot[i].addVelocity(xv, yv, 0 );
        }
    }
    public void setColor(color c) {
        fillColor = c;
    }

    public void draw() {
        Particle p1, p2;

        for (int i = 0; i < 7; i++) {
            //p1 = segment[i].getOneEnd();
            //p2 = segment[i].getTheOtherEnd();
            if (lit[digit][i]) {
                stroke(255);          
                strokeWeight(1);      
                fill(fillColor);


            } 
            else {
                stroke(255);          
                strokeWeight(1);      
                fill(245, 245, 245, 200);            
            }

            beginShape(POLYGON); 
            for (int j = 0; j < segs[i].length; j++) {
                vertex(dot[segs[i][j]].position().x(), dot[segs[i][j]].position().y()); 
            }
            endShape();                
            stroke(245, 245, 245, 200);
            strokeWeight(1.0);


            line(hang.position().x(), hang.position().y(), dot[0].position().x(), dot[0].position().y());
            line(hang.position().x(), hang.position().y(), dot[1].position().x(), dot[1].position().y());

        }
        stroke(0);
    }
    private float dist(Particle p1, Particle p2) {
        float x1 = p1.position().x();
        float y1 = p1.position().y();
        float x2 = p2.position().x();
        float y2 = p2.position().y();

        return sqrt( (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2) );
    }
    //for (int i = 0; i < dot.length; i++) {
    //  point(dot[i].position().x(), dot[i].position().y());
    //}

}