/*  This code is based on Apple's "GeekGameBoard" sample code, version 1.0.

    http://developer.apple.com/samplecode/GeekGameBoard/

    Copyright © 2007 Apple Inc. Copyright © 2008 Jens Alfke. All Rights Reserved.

    Redistribution and use in source and binary forms, with or without modification, are permitted

    provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions

      and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright notice, this list of

      conditions and the following disclaimer in the documentation and/or other materials provided

      with the distribution.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR

    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 

    FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRI-

    BUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 

    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 

    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 

    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#import "BoardView.h"

#import "Bit.h"

#import "BitHolder.h"

#import "Game+Protected.h"

#import "Turn.h"

#import "Player.h"

#import "QuartzUtils.h"

#import "GGBUtils.h"

#define kMaxPerspective 0.965   // 55 degrees

@interface BoardView ()

- (void) _findDropTarget: (NSPoint)pos;

@end

@implementation BoardView

@synthesize table=_table, gameBoardInset=_gameBoardInset;

- (void) dealloc

{

    [_game release];

    [super dealloc];

}

- (void) _applyPerspective

{

    CATransform3D t;

    if( fabs(_perspective) >= M_PI/180 ) {

        CGSize size = self.layer.bounds.size;

        t = CATransform3DMakeTranslation(-size.width/2, -size.height/4, 0);

        t = CATransform3DConcat(t, CATransform3DMakeRotation(-_perspective, 1,0,0));

        CATransform3D pers = CATransform3DIdentity;

        pers.m34 = 1.0/-800;

        t = CATransform3DConcat(t, pers);

        t = CATransform3DConcat(t, CATransform3DMakeTranslation(size.width/2, 

                                                                size.height*(0.25 + 0.05*sin(2*_perspective)),

                                                                0));

        self.layer.borderWidth = 3;

    } else {

        t = CATransform3DIdentity;

        self.layer.borderWidth = 0;

    }

    self.layer.transform = t;

}    

- (CGFloat) perspective {return _perspective;}

- (void) setPerspective: (CGFloat)p

{

    p = MAX(0.0, MIN(kMaxPerspective, p));

    if( p != _perspective ) {

        _perspective = p;

        [self _applyPerspective];

        _game.tablePerspectiveAngle = p;

    }

}

- (void) _removeGameBoard

{

    if( _table ) {

        RemoveImmediately(_table);

        _table = nil;

    }

}

- (void) createGameBoard

{

    [self _removeGameBoard];

    _table = [[CALayer alloc] init];

    _table.frame = [self gameBoardFrame];

    _table.autoresizingMask = kCALayerMinXMargin | kCALayerMaxXMargin | kCALayerMinYMargin | kCALayerMaxYMargin;

    // Tell the game to set up the board:

    _game.table = _table;

    [self.layer addSublayer: _table];

    [_table release];

}

- (Game*) game

{

    return _game;

}

- (void) setGame: (Game*)game

{

    if( game!=_game ) {

        _game.table = nil;

        setObj(&_game,game);

        [self createGameBoard];

    }

}

- (void) startGameNamed: (NSString*)gameClassName

{

    Class gameClass = NSClassFromString(gameClassName);

    Game *game = [[gameClass alloc] init];

    if( game ) {

        self.game = game;

        [game release];

    }

}

- (CGRect) gameBoardFrame

{

    return CGRectInset(self.layer.bounds, _gameBoardInset.width,_gameBoardInset.height);

}

- (void)resetCursorRects

{

    [super resetCursorRects];

    if( _game.okToMove )

        [self addCursorRect: self.bounds cursor: [NSCursor openHandCursor]];

}

- (NSView*) fullScreenView

{

    return _fullScreenView ?: self;

}

- (IBAction) enterFullScreen: (id)sender

{

    //[self _removeGameBoard];

    if( self.fullScreenView.isInFullScreenMode ) {

        [self.fullScreenView exitFullScreenModeWithOptions: nil];

    } else {

        [self.fullScreenView enterFullScreenMode: self.window.screen 

                                     withOptions: nil];

    }

    //[self createGameBoard];

}

- (void)viewWillStartLiveResize

{

    [super viewWillStartLiveResize];

    _oldSize = self.frame.size;

}

- (void)setFrameSize:(NSSize)newSize

{

    [super setFrameSize: newSize];

    if( _oldSize.width > 0.0f ) {

        CGAffineTransform xform = _table.affineTransform;

        xform.a = xform.d = MIN(newSize.width,newSize.height)/MIN(_oldSize.width,_oldSize.height);

        BeginDisableAnimations();

        [self _applyPerspective];

        _table.affineTransform = xform;

        EndDisableAnimations();

    } else

        [self createGameBoard];

}

- (void)viewDidEndLiveResize

{

    [super viewDidEndLiveResize];

    _oldSize.width = _oldSize.height = 0.0f;

    [self createGameBoard];

}

#pragma mark -

#pragma mark KEY EVENTS:

- (BOOL) performKeyEquivalent: (NSEvent*)ev

{

    if( [ev.charactersIgnoringModifiers hasPrefix: @"\033"] ) {       // Esc key

        if( self.fullScreenView.isInFullScreenMode ) {

            [self performSelector: @selector(enterFullScreen:) withObject: nil afterDelay: 0.0];

            // without the delayed-perform, NSWindow crashes right after this method returns!

            return YES;

        }

    }

    return NO;

}

#pragma mark -

#pragma mark HIT-TESTING:

/** Converts a point from window coords, to this view's root layer's coords. */

- (CGPoint) _convertPointFromWindowToLayer: (NSPoint)locationInWindow

{

    NSPoint where = [self convertPoint: locationInWindow fromView: nil];    // convert to view coords

    where = [self convertPointToBase: where];                               // then to layer base coords

    return [self.layer convertPoint: NSPointToCGPoint(where)                // then to transformed layer coords

                          fromLayer: self.layer.superlayer];

}

// Hit-testing callbacks (to identify which layers caller is interested in):

typedef BOOL (*LayerMatchCallback)(CALayer*);

static BOOL layerIsBit( CALayer* layer )        {return [layer isKindOfClass: [Bit class]];}

static BOOL layerIsBitHolder( CALayer* layer )  {return [layer conformsToProtocol: @protocol(BitHolder)];}

static BOOL layerIsDropTarget( CALayer* layer ) {return [layer respondsToSelector: @selector(draggingEntered:)];}

/** Locates the layer at a given point in window coords.

    If the leaf layer doesn't pass the layer-match callback, the nearest ancestor that does is returned.

    If outOffset is provided, the point's position relative to the layer is stored into it. */

- (CALayer*) hitTestPoint: (NSPoint)locationInWindow

         forLayerMatching: (LayerMatchCallback)match

                   offset: (CGPoint*)outOffset

{

    CGPoint where = [self _convertPointFromWindowToLayer: locationInWindow ];

    CALayer *layer = [_table hitTest: where];

    while( layer ) {

        if( match(layer) ) {

            CGPoint bitPos = [self.layer convertPoint: layer.position 

                              fromLayer: layer.superlayer];

            if( outOffset )

                *outOffset = CGPointMake( bitPos.x-where.x, bitPos.y-where.y);

            return layer;

        } else

            layer = layer.superlayer;

    }

    return nil;

}

#pragma mark -

#pragma mark MOUSE CLICKS & DRAGS:

- (void) mouseDown: (NSEvent*)ev

{

    if( ! _game.okToMove ) {

        NSBeep();

        return;

    }

    BOOL placing = NO;

    _dragStartPos = ev.locationInWindow;

    _dragBit = (Bit*) [self hitTestPoint: _dragStartPos

                        forLayerMatching: layerIsBit 

                                  offset: &_dragOffset];

    if( ! _dragBit ) {

        // If no bit was clicked, see if it's a BitHolder the game will let the user add a Bit to:

        id<BitHolder> holder = (id<BitHolder>) [self hitTestPoint: _dragStartPos

                                                 forLayerMatching: layerIsBitHolder

                                                           offset: NULL];

        if( holder ) {

            _dragBit = [_game bitToPlaceInHolder: holder];

            if( _dragBit ) {

                _dragOffset.x = _dragOffset.y = 0;

                if( _dragBit.superlayer==nil )

                    _dragBit.position = [self _convertPointFromWindowToLayer: _dragStartPos];

                placing = YES;

            }

        }

    }

    if( ! _dragBit ) {

        Beep();

        return;

    }

    // Clicked on a Bit:

    _dragMoved = NO;

    _dropTarget = nil;

    _oldHolder = _dragBit.holder;

    // Ask holder's and game's permission before dragging:

    if( _oldHolder ) {

        _dragBit = [_oldHolder canDragBit: _dragBit];

        if( _dragBit && ! [_game canBit: _dragBit moveFrom: _oldHolder] ) {

            [_oldHolder cancelDragBit: _dragBit];

            _dragBit = nil;

        }

        if( ! _dragBit ) {

            _oldHolder = nil;

            NSBeep();

            return;

        }

    }

    // Start dragging:

    _oldSuperlayer = _dragBit.superlayer;

    _oldLayerIndex = [_oldSuperlayer.sublayers indexOfObjectIdenticalTo: _dragBit];

    _oldPos = _dragBit.position;

    ChangeSuperlayer(_dragBit, self.layer, self.layer.sublayers.count);

    _dragBit.pickedUp = YES;

    [[NSCursor closedHandCursor] push];

    if( placing ) {

        if( _oldSuperlayer )

            _dragBit.position = [self _convertPointFromWindowToLayer: _dragStartPos];

        _dragMoved = YES;

        [self _findDropTarget: _dragStartPos];

    }

}

- (void) mouseDragged: (NSEvent*)ev

{

    if( _dragBit ) {

        // Get the mouse position, and see if we've moved 3 pixels since the mouseDown:

        NSPoint pos = ev.locationInWindow;

        if( fabs(pos.x-_dragStartPos.x)>=3 || fabs(pos.y-_dragStartPos.y)>=3 )

            _dragMoved = YES;

        // Move the _dragBit (without animation -- it's unnecessary and slows down responsiveness):

        CGPoint where = [self _convertPointFromWindowToLayer: pos];

        where.x += _dragOffset.x;

        where.y += _dragOffset.y;

        CGPoint newPos = [_dragBit.superlayer convertPoint: where fromLayer: self.layer];

        [CATransaction flush];

        [CATransaction begin];

        [CATransaction setValue:(id)kCFBooleanTrue

                         forKey:kCATransactionDisableActions];

        _dragBit.position = newPos;

        [CATransaction commit];

        // Find what it's over:

        [self _findDropTarget: pos];

    }

}

- (void) _findDropTarget: (NSPoint)locationInWindow

{

    locationInWindow.x += _dragOffset.x;

    locationInWindow.y += _dragOffset.y;

    id<BitHolder> target = (id<BitHolder>) [self hitTestPoint: locationInWindow

                                             forLayerMatching: layerIsBitHolder

                                                       offset: NULL];

    if( target == _oldHolder )

        target = nil;

    if( target != _dropTarget ) {

        [_dropTarget willNotDropBit: _dragBit];

        _dropTarget.highlighted = NO;

        _dropTarget = nil;

    }

    if( target ) {

        CGPoint targetPos = [(CALayer*)target convertPoint: _dragBit.position

                                                 fromLayer: _dragBit.superlayer];

        if( [target canDropBit: _dragBit atPoint: targetPos]

           && [_game canBit: _dragBit moveFrom: _oldHolder to: target] ) {

            _dropTarget = target;

            _dropTarget.highlighted = YES;

        }

    }

}

- (void) mouseUp: (NSEvent*)ev

{

    if( _dragBit ) {

        if( _dragMoved ) {

            // Update the drag tracking to the final mouse position:

            [self mouseDragged: ev];

            _dropTarget.highlighted = NO;

            _dragBit.pickedUp = NO;

            // Is the move legal?

            if( _dropTarget && [_dropTarget dropBit: _dragBit

                                            atPoint: [(CALayer*)_dropTarget convertPoint: _dragBit.position 

                                                                            fromLayer: _dragBit.superlayer]] ) {

                // Yes, notify the interested parties:

                [_oldHolder draggedBit: _dragBit to: _dropTarget];

                [_game bit: _dragBit movedFrom: _oldHolder to: _dropTarget];

            } else {

                // Nope, cancel:

                [_dropTarget willNotDropBit: _dragBit];

                if( _oldSuperlayer ) {

                    ChangeSuperlayer(_dragBit, _oldSuperlayer, _oldLayerIndex);

                    _dragBit.position = _oldPos;

                    [_oldHolder cancelDragBit: _dragBit];

                } else {

                    [_dragBit removeFromSuperlayer];

                }

            }

        } else {

            // Just a click, without a drag:

            _dropTarget.highlighted = NO;

            _dragBit.pickedUp = NO;

            ChangeSuperlayer(_dragBit, _oldSuperlayer, _oldLayerIndex);

            [_oldHolder cancelDragBit: _dragBit];

            if( ! [_game clickedBit: _dragBit] )

                NSBeep();

        }

        _dropTarget = nil;

        _dragBit = nil;

        [NSCursor pop];

    }

}

- (void)scrollWheel:(NSEvent *)e

{

    self.perspective += e.deltaY * M_PI/180;

    //Log(@"Perspective = %2.0f degrees (%5.3f radians)", self.perspective*180/M_PI, self.perspective);

}

#pragma mark -

#pragma mark INCOMING DRAGS:

// subroutine to call the target

static int tell( id target, SEL selector, id arg, int defaultValue )

{

    if( target && [target respondsToSelector: selector] )

        return (ssize_t) [target performSelector: selector withObject: arg];

    else

        return defaultValue;

}

- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender

{

    _viewDropTarget = [self hitTestPoint: [sender draggingLocation]

                        forLayerMatching: layerIsDropTarget

                                  offset: NULL];

    _viewDropOp = _viewDropTarget ?[_viewDropTarget draggingEntered: sender] :NSDragOperationNone;

    return _viewDropOp;

}

- (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender

{

    CALayer *target = [self hitTestPoint: [sender draggingLocation]

                        forLayerMatching: layerIsDropTarget 

                                  offset: NULL];

    if( target == _viewDropTarget ) {

        if( _viewDropTarget )

            _viewDropOp = tell(_viewDropTarget,@selector(draggingUpdated:),sender,_viewDropOp);

    } else {

        tell(_viewDropTarget,@selector(draggingExited:),sender,0);

        _viewDropTarget = target;

        if( _viewDropTarget )

            _viewDropOp = [_viewDropTarget draggingEntered: sender];

        else

            _viewDropOp = NSDragOperationNone;

    }

    return _viewDropOp;

}

- (BOOL)wantsPeriodicDraggingUpdates

{

    return (_viewDropTarget!=nil);

}

- (void)draggingExited:(id <NSDraggingInfo>)sender

{

    tell(_viewDropTarget,@selector(draggingExited:),sender,0);

    _viewDropTarget = nil;

}

- (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender

{

    return tell(_viewDropTarget,@selector(prepareForDragOperation:),sender,YES);

}

- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender

{

    return [_viewDropTarget performDragOperation: sender];

}

- (void)concludeDragOperation:(id <NSDraggingInfo>)sender

{

    tell(_viewDropTarget,@selector(concludeDragOperation:),sender,0);

}

- (void)draggingEnded:(id <NSDraggingInfo>)sender

{

    tell(_viewDropTarget,@selector(draggingEnded:),sender,0);

}

@end