#import "Views.h"
#import "Controller.h"


@implementation Rubik

- initAtPoint:(NSPoint)aPoint controller:(id)theCon
{
    NSRect frame;
    int x, y, z, b1, b2, index;
    
    frame.origin = aPoint;
    frame.size.width = frame.size.height = DIMENSION;

    [super initWithFrame:frame];
    [self setBoundsSize:NSMakeSize(4.0, 4.0)];
    [self setBoundsOrigin:NSMakePoint(-2.0, -2.0)];

    con = theCon;

    for(x=-1; x<=1; x+=2){
        for(y=-1; y<=1; y+=2){
            for(z=-1; z<=1; z+=2){
                int index = 
                    4*(x==-1 ? 0 : 1)+
                    2*(y==-1 ? 0 : 1)+
                    (z==-1 ? 0 : 1);
                vertices[index].x = x;
                vertices[index].y = y;
                vertices[index].z = z;
                vertices[index].index = index;

                colors[index] =
                    [NSColor colorWithDeviceRed:(x==-1 ? 0.0 : 1.0)
                             green:(y==-1 ? 0.0 : 1.0)
                             blue:(z==-1 ? 0.0 : 1.0)
                             alpha:1.0];
                [colors[index] retain];
            }
        }
    }

    index = 0;
    for(b1=0; b1<=2; b1++){
        for(b2=b1+1; b2<=2; b2++){
            /* counterclockwise */
            int reorient = index + 1-(index/2)%2;
            int temp;

            face[index][0] = 0;
            face[index][1] = face[index][0]+(1<<b1);
            face[index][2] = face[index][1]+(1<<b2);
            face[index][3] = face[index][2]-(1<<b1);

            index++;

            face[index][0] = 1<<(3-b1-b2);
            face[index][1] = face[index][0]+(1<<b1);
            face[index][2] = face[index][1]+(1<<b2);
            face[index][3] = face[index][2]-(1<<b1);
            
            index++;

            temp = face[reorient][0];
            face[reorient][0] = face[reorient][3];
            face[reorient][3] = temp;
            temp = face[reorient][1];
            face[reorient][1] = face[reorient][2];
            face[reorient][2] = temp;
        }
    }

    for(index=0; index<6; index++){
        int vx;
        
        printf("%d : %d %d %d %d:", index,
               face[index][0],
               face[index][1],
               face[index][2],
               face[index][3]);
        
        for(vx=0; vx<4; vx++){
            int v1 = face[index][vx], v2 = face[index][(vx+1)%4];
            int f;
            for(f=0; f<6; f++){
                if(f!=index){
                    int e; BOOL found = NO;

                    for(e=0; e<4; e++){
                        if(v1 == face[f][e] && 
                           v2 == face[f][(e+3)%4]){
                            found = YES;

                            adjacent[index][vx] = f;
                            edge[index][vx] = (e+3)%4;
                        }
                    }

                    if(found==YES){
                        printf(" (%d %d)",
                               adjacent[index][vx],
                               edge[index][vx]);
                    }
                }
            }
        }

        printf("\n");
    }


    [self resetCube];
    [self recomputeGeometry];

    return self;
}

- scramble
{
    int fprev = -1, fcur, index;

    for(index=0; index<SCRAMBLE; index++){
        do {
            fcur = lrand48()%6;
        } while(fcur==fprev);

        [self rotateFace:fcur clockwise:YES];

        fprev = fcur;
    }

    return self;
}

- resetCube
{
    int f, row, col;

    angle = 0;
    rprev = rcur = -1;

    memcpy(indexed, vertices, 8*sizeof(Vertex));
    memcpy(active,  vertices, 8*sizeof(Vertex));

    for(f=0; f<6; f++){
        for(row=0; row<3; row++){
            for(col=0; col<3; col++){
                data[f][row][col] = f+1;
            }
        }
    }

    return self;
}

- rotate:(Vertex *)vp aboutUnitVector:(ROT_ACTIVE)rv
   angle:(double)theta

{
    double cosTheta = cos(theta), sinTheta = sin(theta);
    int index;

    for(index=0; index<8; index++){
        Vertex *v = vp+index;
        double x = v->x, y = v->y, z = v->z;

        switch(rv){
            case ROT_X:
                v->y = y * cosTheta - z * sinTheta;
                v->z = y * sinTheta + z * cosTheta;
                break;
            case ROT_Y:
                v->x = x * cosTheta - z * sinTheta;
                v->z = x * sinTheta + z * cosTheta;
                break;
            case ROT_Z:
                v->x = x * cosTheta - y * sinTheta;
                v->y = x * sinTheta + y * cosTheta;
        }
    }

    return self;
}

- recomputeGeometry
{
    int index, findex, upper;

    if(rcur!=rprev){
        [self rotate:active aboutUnitVector:rcur angle:-angle];
        memcpy(indexed, active, 8*sizeof(Vertex));
        rprev = rcur;

        /*
        {
            double 
                dx = indexed[0].x-indexed[1].x,
                dy = indexed[0].y-indexed[1].y,
                dz = indexed[0].z-indexed[1].z;

            NSLog(@"%le\n", dx*dx+dy*dy+dz*dz);
        }
        */
    }

    memcpy(active, indexed, 8*sizeof(Vertex));
    [self rotate:active aboutUnitVector:rcur angle:angle];
    memcpy(sorted, active, 8*sizeof(Vertex));

    for(upper=6; upper>=0; upper--){
        for(index=0; index<=upper; index++){
            if(sorted[index].y>sorted[index+1].y){
                Vertex current;
                current = sorted[index];
                sorted[index] = sorted[index+1];
                sorted[index+1] = current;
            }
        }
    }

    index = 0;
    for(index=1; index<8; index++){
        double delta = sorted[index].y-sorted[index-1].y;
        if(delta>DELTA){
            break;
        }
    }

    if(index==1){
        int v = sorted[0].index;

        vis = VIS_F_3;

        findex = 0;
        for(index=0; index<6; index++){
            if(face[index][0]==v ||
               face[index][1]==v ||
               face[index][2]==v ||
               face[index][3]==v){
                visface[findex++] = index;
            }
        }
    } else if(index==2){
        int v1 = sorted[0].index, v2 = sorted[1].index;

        vis = VIS_F_2;
        
        findex = 0;
        for(index=0; index<6; index++){
            if((face[index][0]==v1 ||
                face[index][1]==v1 ||
                face[index][2]==v1 ||
                face[index][3]==v1) &&
               (face[index][0]==v2 ||
                face[index][1]==v2 ||
                face[index][2]==v2 ||
                face[index][3]==v2)){
                visface[findex++] = index;
            }
        }
    } else {
        int v1 = sorted[0].index, v2 = sorted[1].index,
            v3 = sorted[2].index, v4 = sorted[3].index;

        vis = VIS_F_1;

        findex = 0;
        for(index=0; index<6; index++){
            if((face[index][0]==v1 ||
                face[index][1]==v1 ||
                face[index][2]==v1 ||
                face[index][3]==v1) &&
               (face[index][0]==v2 ||
                face[index][1]==v2 ||
                face[index][2]==v2 ||
                face[index][3]==v2) &&
               (face[index][0]==v3 ||
                face[index][1]==v3 ||
                face[index][2]==v3 ||
                face[index][3]==v3) &&
               (face[index][0]==v4 ||
                face[index][1]==v4 ||
                face[index][2]==v4 ||
                face[index][3]==v4)){
                visface[findex++] = index;
            }
        }
    }
        
    [self setNeedsDisplay:YES];

    return self;
}

- angle:(id)sender
{
    angle = [sender doubleValue];
    rcur = [sender tag];

    [self recomputeGeometry];
    return self;
}

- (BOOL)solved
{
    int f, row, col;

    for(f=0; f<6; f++){
        for(row=0; row<3; row++){
            for(col=0; col<3; col++){
                if(data[f][row][col]!=data[f][1][1]){
                    return NO;
                }
            }
        }
    }

    return YES;
}

- (void)drawRect:(NSRect)aRect
{
    NSRect bounds = [self bounds];
    int findex;

    [colors[0] set];
    PSrectfill(bounds.origin.x, bounds.origin.y,
               bounds.size.width, bounds.size.height);

    PSsetlinewidth(4.0/(float)DIMENSION);

    for(findex=0; findex<vis; findex++){
        int f = visface[findex];
        NSPoint p0 = { active[face[f][0]].x,
                       active[face[f][0]].z };
        NSPoint p1 = { active[face[f][1]].x, 
                       active[face[f][1]].z };
        NSPoint p2 = { active[face[f][2]].x, 
                       active[face[f][2]].z };

        NSPoint ivall = { p1.x - p0.x, p1.y - p0.y };
        NSPoint jvall = { p2.x - p1.x, p2.y - p1.y };
        NSPoint ivect = { ivall.x/3.0, ivall.y/3.0 };
        NSPoint jvect = { jvall.x/3.0, jvall.y/3.0 };

        int row, col, k;
        
        for(row=0; row<3; row++){
            for(col=0; col<3; col++){
                [colors[data[f][row][col]] set];

                PSmoveto(p0.x+col*ivect.x+row*jvect.x,
                         p0.y+col*ivect.y+row*jvect.y);
                PSrlineto(ivect.x, ivect.y);
                PSrlineto(jvect.x, jvect.y);
                PSrlineto(-ivect.x, -ivect.y);
                PSrlineto(-jvect.x, -jvect.y);

                PSfill();
            }
        }
                
        [colors[7] set];

        for(k=0; k<=3; k++){
            PSmoveto(p0.x+k*ivect.x, p0.y+k*ivect.y);
            PSrlineto(jvall.x, jvall.y);
            PSmoveto(p0.x+k*jvect.x, p0.y+k*jvect.y);
            PSrlineto(ivall.x, ivall.y);
        }

        PSstroke();
    }
}

- (int)visFaceClicked:(NSPoint)loc
{
    int findex;

    for(findex=0; findex<vis; findex++){
        int f = visface[findex];
        NSPoint p0 = { active[face[f][0]].x,
                       active[face[f][0]].z };
        NSPoint p1 = { active[face[f][1]].x, 
                       active[face[f][1]].z };
        NSPoint p2 = { active[face[f][2]].x, 
                       active[face[f][2]].z };

        NSPoint ivall = { p1.x - p0.x, p1.y - p0.y };
        NSPoint jvall = { p2.x - p1.x, p2.y - p1.y };

        NSPoint p = { loc.x - p0.x, loc.y - p0.y };

        float s, t, det;

        det = ivall.x * jvall.y - ivall.y * jvall.x;
        if(det!=0.0){
            s = (p.x * jvall.y - p.y * jvall.x)/det;
            t = (ivall.x * p.y - ivall.y * p.x)/det;

            if(0.0 <= s && s <= 1.0 && 0.0 <= t && t <= 1.0){
                return f;
            }
        }
    }

    return -1;
}

- rotateFace:(int)f clockwise:(BOOL)flag
{
    int fbuf[3][3];
    int row, col;

    int e, lbuf[4][3], offs = (flag==YES ? 3 : 1);

    for(row=0; row<3; row++){
        for(col=0; col<3; col++){
            fbuf[row][col] = data[f][row][col];
        }
    }

    if(flag==YES){
        data[f][0][0] = fbuf[0][2];
        data[f][2][0] = fbuf[0][0];
        data[f][2][2] = fbuf[2][0];
        data[f][0][2] = fbuf[2][2];
        
        data[f][0][1] = fbuf[1][2];
        data[f][1][0] = fbuf[0][1];
        data[f][2][1] = fbuf[1][0];
        data[f][1][2] = fbuf[2][1];
    }
    else{
        data[f][0][0] = fbuf[2][0];
        data[f][2][0] = fbuf[2][2];
        data[f][2][2] = fbuf[0][2];
        data[f][0][2] = fbuf[0][0];
        
        data[f][0][1] = fbuf[1][0];
        data[f][1][0] = fbuf[2][1];
        data[f][2][1] = fbuf[1][2];
        data[f][1][2] = fbuf[0][1];
    }

    data[f][1][1] = fbuf[1][1];

    for(e=0; e<4; e++){
        int sface = adjacent[f][e];
        int sedge = edge[f][e];

        switch(sedge){
            case 0:
                lbuf[e][0] = data[sface][0][0];
                lbuf[e][1] = data[sface][0][1];
                lbuf[e][2] = data[sface][0][2];
                break;
            case 1:
                lbuf[e][0] = data[sface][0][2];
                lbuf[e][1] = data[sface][1][2];
                lbuf[e][2] = data[sface][2][2];
                break;
            case 2:
                lbuf[e][0] = data[sface][2][2];
                lbuf[e][1] = data[sface][2][1];
                lbuf[e][2] = data[sface][2][0];
                break;
            case 3:
                lbuf[e][0] = data[sface][2][0];
                lbuf[e][1] = data[sface][1][0];
                lbuf[e][2] = data[sface][0][0];
        }
    }

    for(e=0; e<4; e++){
        int sface = adjacent[f][(e+offs)%4];
        int sedge = edge[f][(e+offs)%4];

        switch(sedge){
            case 0:
                data[sface][0][0] = lbuf[e][0];
                data[sface][0][1] = lbuf[e][1];
                data[sface][0][2] = lbuf[e][2];
                break;
            case 1:
                data[sface][0][2] = lbuf[e][0];
                data[sface][1][2] = lbuf[e][1];
                data[sface][2][2] = lbuf[e][2];
                break;
            case 2:
                data[sface][2][2] = lbuf[e][0];
                data[sface][2][1] = lbuf[e][1];
                data[sface][2][0] = lbuf[e][2];
                break;
            case 3:
                data[sface][2][0] = lbuf[e][0];
                data[sface][1][0] = lbuf[e][1];
                data[sface][0][0] = lbuf[e][2];
        }
    }
            
    return self;
}


- (void)mouseDown:(NSEvent *)theEvent
{
    int f;
    NSPoint curp = [theEvent locationInWindow];
    curp = [self convertPoint:curp fromView:nil];
    
    if((f=[self visFaceClicked:curp])!=-1){
        [self rotateFace:f clockwise:YES];
        [self setNeedsDisplay:YES];

        if([self solved]==YES){
            NSRunAlertPanel(@"Congratulations!", @"Cube solved.",
                            @"Ok", nil, nil);
        }
    }
}

- (void)rightMouseDown:(NSEvent *)theEvent
{
    int f;
    NSPoint curp = [theEvent locationInWindow];
    curp = [self convertPoint:curp fromView:nil];
    
    if((f=[self visFaceClicked:curp])!=-1){
        [self rotateFace:f clockwise:NO];
        [self setNeedsDisplay:YES];

        if([self solved]==YES){
            NSRunAlertPanel(@"Congratulations!", @"Cube solved.",
                            @"Ok", nil, nil);
        }
    }
}

@end