#include "boo/graphicsdev/GL.hpp"
#import <AppKit/AppKit.h>
#import <CoreVideo/CVDisplayLink.h>
#include "boo/IApplication.hpp"
#include "boo/IWindow.hpp"
#include "boo/IGraphicsContext.hpp"

#include <LogVisor/LogVisor.hpp>

namespace boo {class WindowCocoa;}
@interface WindowCocoaInternal : NSWindow
{
    boo::WindowCocoa* booWindow;
}
- (id)initWithBooWindow:(boo::WindowCocoa*)bw title:(const std::string&)title;
- (void)setFrameDefault;
- (NSRect)genFrameDefault;
@end
    
/* AppKit applies OpenGL much differently than other platforms
 * the NSOpenGLView class composes together all necessary
 * OGL context members and provides the necessary event hooks
 * for KB/Mouse/Touch events
 */

static const NSOpenGLPixelFormatAttribute PF_RGBA8_ATTRS[] =
{
    NSOpenGLPFAAccelerated,
    NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
    NSOpenGLPFADoubleBuffer,
    NSOpenGLPFAColorSize, 24,
    NSOpenGLPFAAlphaSize, 8,
};

static const NSOpenGLPixelFormatAttribute PF_RGBA8_Z24_ATTRS[] =
{
    NSOpenGLPFAAccelerated,
    NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
    NSOpenGLPFADoubleBuffer,
    NSOpenGLPFAColorSize, 24,
    NSOpenGLPFAAlphaSize, 8,
    NSOpenGLPFADepthSize, 24,
};

static const NSOpenGLPixelFormatAttribute PF_RGBAF32_ATTRS[] =
{
    NSOpenGLPFAAccelerated,
    NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
    NSOpenGLPFADoubleBuffer,
    NSOpenGLPFAColorFloat,
    NSOpenGLPFAColorSize, 96,
    NSOpenGLPFAAlphaSize, 32,
};

static const NSOpenGLPixelFormatAttribute PF_RGBAF32_Z24_ATTRS[] =
{
    NSOpenGLPFAAccelerated,
    NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
    NSOpenGLPFADoubleBuffer,
    NSOpenGLPFAColorFloat,
    NSOpenGLPFAColorSize, 96,
    NSOpenGLPFAAlphaSize, 32,
    NSOpenGLPFADepthSize, 24,
};

static const NSOpenGLPixelFormatAttribute* PF_TABLE[] =
{
    NULL,
    PF_RGBA8_ATTRS,
    PF_RGBA8_Z24_ATTRS,
    PF_RGBAF32_ATTRS,
    PF_RGBAF32_Z24_ATTRS
};

namespace boo {class GraphicsContextCocoa;}
@interface GraphicsContextCocoaInternal : NSOpenGLView
{
    NSUInteger lastModifiers;
    boo::GraphicsContextCocoa* booContext;
}
- (id)initWithBooContext:(boo::GraphicsContextCocoa*)bctx;
@end
    
namespace boo
{
static LogVisor::LogModule Log("boo::WindowCocoa");
IGraphicsCommandQueue* _NewGLES3CommandQueue(IGraphicsContext* parent);
void _CocoaUpdateLastGLCtx(NSOpenGLContext* lastGLCtx);

class GraphicsContextCocoa : public IGraphicsContext
{
    
    EGraphicsAPI m_api;
    EPixelFormat m_pf;
    IWindow* m_parentWindow;
    GraphicsContextCocoaInternal* m_nsContext = nullptr;
    
    IGraphicsCommandQueue* m_commandQueue = nullptr;
    IGraphicsDataFactory* m_dataFactory = nullptr;
    NSOpenGLContext* m_loadCtx = nullptr;
    CVDisplayLinkRef m_dispLink = nullptr;
    
public:
    NSOpenGLContext* m_lastCtx = nullptr;
    IWindowCallback* m_callback = nullptr;
    
    GraphicsContextCocoa(EGraphicsAPI api, IWindow* parentWindow, NSOpenGLContext* lastGLCtx)
    : m_api(api),
    m_pf(PF_RGBA8),
    m_parentWindow(parentWindow),
    m_lastCtx(lastGLCtx)
    {}
    
    ~GraphicsContextCocoa()
    {
        delete m_dataFactory;
        delete m_commandQueue;
        [m_nsContext release];
        [m_loadCtx release];
        CVDisplayLinkStop(m_dispLink);
        CVDisplayLinkRelease(m_dispLink);
    }
    
    void _setCallback(IWindowCallback* cb)
    {
        m_callback = cb;
    }
    
    EGraphicsAPI getAPI() const
    {
        return m_api;
    }
    
    EPixelFormat getPixelFormat() const
    {
        return m_pf;
    }
    
    void setPixelFormat(EPixelFormat pf)
    {
        if (pf > PF_RGBAF32_Z24)
            return;
        m_pf = pf;
    }
    
    std::mutex m_dlmt;
    std::condition_variable m_dlcv;
    
    static CVReturn DLCallback(CVDisplayLinkRef CV_NONNULL displayLink,
                               const CVTimeStamp * CV_NONNULL inNow,
                               const CVTimeStamp * CV_NONNULL inOutputTime,
                               CVOptionFlags flagsIn,
                               CVOptionFlags * CV_NONNULL flagsOut,
                               GraphicsContextCocoa* CV_NULLABLE ctx)
    {
        ctx->m_dlcv.notify_one();
        return kCVReturnSuccess;
    }
    
    void waitForRetrace()
    {
        std::unique_lock<std::mutex> lk(m_dlmt);
        m_dlcv.wait(lk);
    }
    
    void initializeContext()
    {
        m_nsContext = [[GraphicsContextCocoaInternal alloc] initWithBooContext:this];
        if (!m_nsContext)
            Log.report(LogVisor::FatalError, "unable to make new NSOpenGLView");
        [(NSWindow*)m_parentWindow->getPlatformHandle() setContentView:m_nsContext];
        CVDisplayLinkCreateWithActiveCGDisplays(&m_dispLink);
        CVDisplayLinkSetOutputCallback(m_dispLink, (CVDisplayLinkOutputCallback)DLCallback, this);
        CVDisplayLinkStart(m_dispLink);
    }
    
    void makeCurrent()
    {
        [[m_nsContext openGLContext] makeCurrentContext];
    }
    
    void postInit()
    {
    }
    
    IGraphicsCommandQueue* getCommandQueue()
    {
        if (!m_commandQueue)
            m_commandQueue = _NewGLES3CommandQueue(this);
        return m_commandQueue;
    }
    
    IGraphicsDataFactory* getDataFactory()
    {
        if (!m_dataFactory)
            m_dataFactory = new GLDataFactory(this);
        return m_dataFactory;
    }
    
    IGraphicsDataFactory* getLoadContextDataFactory()
    {
        if (!m_loadCtx)
        {
            NSOpenGLPixelFormat* nspf = [[NSOpenGLPixelFormat alloc] initWithAttributes:PF_TABLE[m_pf]];
            m_loadCtx = [[NSOpenGLContext alloc] initWithFormat:nspf shareContext:[m_nsContext openGLContext]];
            [nspf release];
            if (!m_loadCtx)
                Log.report(LogVisor::FatalError, "unable to make load NSOpenGLContext");
            [m_loadCtx makeCurrentContext];
        }
        return getDataFactory();
    }
    
    void present()
    {
        [[m_nsContext openGLContext] flushBuffer];
    }
    
};

IGraphicsContext* _GraphicsContextCocoaNew(IGraphicsContext::EGraphicsAPI api,
                                           IWindow* parentWindow, NSOpenGLContext* lastGLCtx)
{
    if (api != IGraphicsContext::API_OPENGL_3_3 && api != IGraphicsContext::API_OPENGL_4_2)
        return NULL;
    
    /* Create temporary context to query GL version */
    NSOpenGLPixelFormat* nspf = [[NSOpenGLPixelFormat alloc] initWithAttributes:PF_RGBA8_ATTRS];
    if (!nspf)
        return NULL;
    NSOpenGLContext* nsctx = [[NSOpenGLContext alloc] initWithFormat:nspf shareContext:nil];
    [nspf release];
    if (!nsctx)
        return NULL;
    [nsctx makeCurrentContext];
    const char* glVersion = (char*)glGetString(GL_VERSION);
    unsigned major = 0;
    unsigned minor = 0;
    if (glVersion)
    {
        major = glVersion[0] - '0';
        minor = glVersion[2] - '0';
    }
    [NSOpenGLContext clearCurrentContext];
    [nsctx release];
    if (!glVersion)
        return NULL;
    
    if (major > 4 || (major == 4 && minor >= 2))
        api = IGraphicsContext::API_OPENGL_4_2;
    else if (major == 3 && minor >= 3)
        if (api == IGraphicsContext::API_OPENGL_4_2)
            return NULL;
    
    return new GraphicsContextCocoa(api, parentWindow, lastGLCtx);
}
    
}
    
@implementation GraphicsContextCocoaInternal
- (id)initWithBooContext:(boo::GraphicsContextCocoa*)bctx
{
    lastModifiers = 0;
    booContext = bctx;
    boo::IGraphicsContext::EPixelFormat pf = bctx->getPixelFormat();
    NSOpenGLPixelFormat* nspf = [[NSOpenGLPixelFormat alloc] initWithAttributes:PF_TABLE[pf]];
    self = [self initWithFrame:NSMakeRect(0, 0, 100, 100) pixelFormat:nspf];
    if (bctx->m_lastCtx)
    {
        NSOpenGLContext* sharedCtx = [[NSOpenGLContext alloc] initWithFormat:nspf shareContext:bctx->m_lastCtx];
        [self setOpenGLContext:sharedCtx];
        [sharedCtx setView:self];
    }
    [nspf release];
    return self;
}

- (void)reshape
{
    boo::SWindowRect rect = {{int(self.frame.origin.x), int(self.frame.origin.y)},
                             {int(self.frame.size.width), int(self.frame.size.height)}};
    booContext->m_callback->resized(rect);
    [super reshape];
}

- (BOOL)acceptsTouchEvents
{
    return YES;
}

static inline boo::EModifierKey getMod(NSUInteger flags)
{
    int ret = boo::MKEY_NONE;
    if (flags & NSControlKeyMask)
        ret |= boo::MKEY_CTRL;
    if (flags & NSAlternateKeyMask)
        ret |= boo::MKEY_ALT;
    if (flags & NSShiftKeyMask)
        ret |= boo::MKEY_SHIFT;
    if (flags & NSCommandKeyMask)
        ret |= boo::MKEY_COMMAND;
    return static_cast<boo::EModifierKey>(ret);
}

static inline boo::EMouseButton getButton(NSEvent* event)
{
    NSInteger buttonNumber = event.buttonNumber;
    if (buttonNumber == 3)
        return boo::BUTTON_MIDDLE;
    else if (buttonNumber == 4)
        return boo::BUTTON_AUX1;
    else if (buttonNumber == 5)
        return boo::BUTTON_AUX2;
    return boo::BUTTON_NONE;
}

- (void)mouseDown:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseDown(coord, boo::BUTTON_PRIMARY,
                                      getMod([theEvent modifierFlags]));
}

- (void)mouseUp:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseUp(coord, boo::BUTTON_PRIMARY,
                                    getMod([theEvent modifierFlags]));
}

- (void)rightMouseDown:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseDown(coord, boo::BUTTON_SECONDARY,
                                      getMod([theEvent modifierFlags]));
}

- (void)rightMouseUp:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseUp(coord, boo::BUTTON_SECONDARY,
                                    getMod([theEvent modifierFlags]));
}

- (void)otherMouseDown:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    boo::EMouseButton button = getButton(theEvent);
    if (!button)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseDown(coord, button, getMod([theEvent modifierFlags]));
}

- (void)otherMouseUp:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    boo::EMouseButton button = getButton(theEvent);
    if (!button)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseUp(coord, button, getMod([theEvent modifierFlags]));
}

- (void)mouseMoved:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    booContext->m_callback->mouseMove(coord);
}
- (void)mouseDragged:(NSEvent*)theEvent
{
    [self mouseMoved:theEvent];
}
- (void)rightMouseDragged:(NSEvent*)theEvent
{
    [self mouseMoved:theEvent];
}
- (void)otherMouseDragged:(NSEvent*)theEvent
{
    [self mouseMoved:theEvent];
}

- (void)scrollWheel:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSPoint liw = [self convertPoint:[theEvent locationInWindow] fromView:nil];
    float pixelFactor = [[self window] backingScaleFactor];
    NSRect frame = [self frame];
    boo::SWindowCoord coord =
    {
        {(unsigned)(liw.x * pixelFactor), (unsigned)(liw.y * pixelFactor)},
        {(unsigned)liw.x, (unsigned)liw.y},
        {(float)(liw.x / frame.size.width), (float)(liw.y / frame.size.height)}
    };
    boo::SScrollDelta scroll =
    {
        {(float)[theEvent scrollingDeltaX], (float)[theEvent scrollingDeltaY]},
        (bool)[theEvent hasPreciseScrollingDeltas]
    };
    booContext->m_callback->scroll(coord, scroll);
}

- (void)touchesBeganWithEvent:(NSEvent*)event
{
    if (!booContext->m_callback)
        return;
    for (NSTouch* touch in [event touchesMatchingPhase:NSTouchPhaseBegan inView:nil])
    {
        NSPoint pos = touch.normalizedPosition;
        boo::STouchCoord coord =
        {
            {(float)pos.x, (float)pos.y}
        };
        booContext->m_callback->touchDown(coord, (uintptr_t)touch.identity);
    }
}

- (void)touchesEndedWithEvent:(NSEvent*)event
{
    if (!booContext->m_callback)
        return;
    for (NSTouch* touch in [event touchesMatchingPhase:NSTouchPhaseEnded inView:nil])
    {
        NSPoint pos = touch.normalizedPosition;
        boo::STouchCoord coord =
        {
            {(float)pos.x, (float)pos.y}
        };
        booContext->m_callback->touchUp(coord, (uintptr_t)touch.identity);
    }
}

- (void)touchesMovedWithEvent:(NSEvent*)event
{
    if (!booContext->m_callback)
        return;
    for (NSTouch* touch in [event touchesMatchingPhase:NSTouchPhaseMoved inView:nil])
    {
        NSPoint pos = touch.normalizedPosition;
        boo::STouchCoord coord =
        {
            {(float)pos.x, (float)pos.y}
        };
        booContext->m_callback->touchMove(coord, (uintptr_t)touch.identity);
    }
}

- (void)touchesCancelledWithEvent:(NSEvent*)event
{
    if (!booContext->m_callback)
        return;
    for (NSTouch* touch in [event touchesMatchingPhase:NSTouchPhaseCancelled inView:nil])
    {
        NSPoint pos = touch.normalizedPosition;
        boo::STouchCoord coord =
        {
            {(float)pos.x, (float)pos.y}
        };
        booContext->m_callback->touchUp(coord, (uintptr_t)touch.identity);
    }
}

/* keycodes for keys that are independent of keyboard layout*/
enum
{
    kVK_Return                    = 0x24,
    kVK_Tab                       = 0x30,
    kVK_Space                     = 0x31,
    kVK_Delete                    = 0x33,
    kVK_Escape                    = 0x35,
    kVK_Command                   = 0x37,
    kVK_Shift                     = 0x38,
    kVK_CapsLock                  = 0x39,
    kVK_Option                    = 0x3A,
    kVK_Control                   = 0x3B,
    kVK_RightShift                = 0x3C,
    kVK_RightOption               = 0x3D,
    kVK_RightControl              = 0x3E,
    kVK_Function                  = 0x3F,
    kVK_F17                       = 0x40,
    kVK_VolumeUp                  = 0x48,
    kVK_VolumeDown                = 0x49,
    kVK_Mute                      = 0x4A,
    kVK_F18                       = 0x4F,
    kVK_F19                       = 0x50,
    kVK_F20                       = 0x5A,
    kVK_F5                        = 0x60,
    kVK_F6                        = 0x61,
    kVK_F7                        = 0x62,
    kVK_F3                        = 0x63,
    kVK_F8                        = 0x64,
    kVK_F9                        = 0x65,
    kVK_F11                       = 0x67,
    kVK_F13                       = 0x69,
    kVK_F16                       = 0x6A,
    kVK_F14                       = 0x6B,
    kVK_F10                       = 0x6D,
    kVK_F12                       = 0x6F,
    kVK_F15                       = 0x71,
    kVK_Help                      = 0x72,
    kVK_Home                      = 0x73,
    kVK_PageUp                    = 0x74,
    kVK_ForwardDelete             = 0x75,
    kVK_F4                        = 0x76,
    kVK_End                       = 0x77,
    kVK_F2                        = 0x78,
    kVK_PageDown                  = 0x79,
    kVK_F1                        = 0x7A,
    kVK_LeftArrow                 = 0x7B,
    kVK_RightArrow                = 0x7C,
    kVK_DownArrow                 = 0x7D,
    kVK_UpArrow                   = 0x7E
};
static boo::ESpecialKey translateKeycode(short code)
{
    switch (code) {
        case kVK_F1:
            return boo::KEY_F1;
        case kVK_F2:
            return boo::KEY_F2;
        case kVK_F3:
            return boo::KEY_F3;
        case kVK_F4:
            return boo::KEY_F4;
        case kVK_F5:
            return boo::KEY_F5;
        case kVK_F6:
            return boo::KEY_F6;
        case kVK_F7:
            return boo::KEY_F7;
        case kVK_F8:
            return boo::KEY_F8;
        case kVK_F9:
            return boo::KEY_F9;
        case kVK_F10:
            return boo::KEY_F10;
        case kVK_F11:
            return boo::KEY_F11;
        case kVK_F12:
            return boo::KEY_F12;
        case kVK_Escape:
            return boo::KEY_ESC;
        case kVK_Return:
            return boo::KEY_ENTER;
        case kVK_Delete:
            return boo::KEY_BACKSPACE;
        case kVK_ForwardDelete:
            return boo::KEY_DELETE;
        case kVK_Home:
            return boo::KEY_HOME;
        case kVK_End:
            return boo::KEY_END;
        case kVK_PageUp:
            return boo::KEY_PGUP;
        case kVK_PageDown:
            return boo::KEY_PGDOWN;
        case kVK_LeftArrow:
            return boo::KEY_LEFT;
        case kVK_RightArrow:
            return boo::KEY_RIGHT;
        case kVK_UpArrow:
            return boo::KEY_UP;
        case kVK_DownArrow:
            return boo::KEY_DOWN;
        default:
            return boo::KEY_NONE;
    }
}

- (void)keyDown:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSString* chars = theEvent.characters;
    if ([chars length] == 0)
        booContext->m_callback->specialKeyDown(translateKeycode(theEvent.keyCode),
                                               getMod(theEvent.modifierFlags),
                                               theEvent.isARepeat);
    else
        booContext->m_callback->charKeyDown([chars characterAtIndex:0],
                                            getMod(theEvent.modifierFlags),
                                            theEvent.isARepeat);
}

- (void)keyUp:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSString* chars = theEvent.characters;
    if ([chars length] == 0)
        booContext->m_callback->specialKeyUp(translateKeycode(theEvent.keyCode),
                                             getMod(theEvent.modifierFlags));
    else
        booContext->m_callback->charKeyUp([chars characterAtIndex:0],
                                          getMod(theEvent.modifierFlags));
}

- (void)flagsChanged:(NSEvent*)theEvent
{
    if (!booContext->m_callback)
        return;
    NSUInteger modFlags = theEvent.modifierFlags;
    bool isRepeat = theEvent.isARepeat;
    if (modFlags != lastModifiers)
    {
        NSUInteger changedFlags = modFlags ^ lastModifiers;
        
        NSUInteger downFlags = changedFlags & modFlags;
        if (downFlags & NSControlKeyMask)
            booContext->m_callback->modKeyDown(boo::MKEY_CTRL, isRepeat);
        if (downFlags & NSAlternateKeyMask)
            booContext->m_callback->modKeyDown(boo::MKEY_ALT, isRepeat);
        if (downFlags & NSShiftKeyMask)
            booContext->m_callback->modKeyDown(boo::MKEY_SHIFT, isRepeat);
        if (downFlags & NSCommandKeyMask)
            booContext->m_callback->modKeyDown(boo::MKEY_COMMAND, isRepeat);
        
        NSUInteger upFlags = changedFlags & ~modFlags;
        if (upFlags & NSControlKeyMask)
            booContext->m_callback->modKeyUp(boo::MKEY_CTRL);
        if (upFlags & NSAlternateKeyMask)
            booContext->m_callback->modKeyUp(boo::MKEY_ALT);
        if (upFlags & NSShiftKeyMask)
            booContext->m_callback->modKeyUp(boo::MKEY_SHIFT);
        if (upFlags & NSCommandKeyMask)
            booContext->m_callback->modKeyUp(boo::MKEY_COMMAND);
        
        lastModifiers = modFlags;
    }
}

@end

namespace boo
{

class WindowCocoa : public IWindow
{
    
    WindowCocoaInternal* m_nsWindow;
    IGraphicsContext* m_gfxCtx;

public:

    WindowCocoa(const std::string& title, NSOpenGLContext* lastGLCtx)
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            m_nsWindow = [[WindowCocoaInternal alloc] initWithBooWindow:this title:title];
            m_gfxCtx = _GraphicsContextCocoaNew(IGraphicsContext::API_OPENGL_3_3, this, lastGLCtx);
            m_gfxCtx->initializeContext();
        });
    }
    
    void _clearWindow()
    {
        m_nsWindow = nullptr;
    }
    
    ~WindowCocoa()
    {
        [m_nsWindow orderOut:nil];
        delete m_gfxCtx;
        [m_nsWindow release];
        APP->_deletedWindow(this);
    }
    
    void setCallback(IWindowCallback* cb)
    {
        m_gfxCtx->_setCallback(cb);
    }
    
    void showWindow()
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            [m_nsWindow makeKeyAndOrderFront:nil];
        });
    }
    
    void hideWindow()
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            [m_nsWindow orderOut:nil];
        });
    }
    
    std::string getTitle()
    {
        return [[m_nsWindow title] UTF8String];
    }
    
    void setTitle(const std::string& title)
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            [m_nsWindow setTitle:[[NSString stringWithUTF8String:title.c_str()] autorelease]];
        });
    }
    
    void setWindowFrameDefault()
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            NSScreen* mainScreen = [NSScreen mainScreen];
            NSRect scrFrame = mainScreen.frame;
            float x_off = scrFrame.size.width / 3.0;
            float y_off = scrFrame.size.height / 3.0;
            [m_nsWindow setFrame:NSMakeRect(x_off, y_off, x_off * 2.0, y_off * 2.0) display:NO];
        });
    }
    
    void getWindowFrame(float& xOut, float& yOut, float& wOut, float& hOut) const
    {
        NSRect wFrame = m_nsWindow.frame;
        xOut = wFrame.origin.x;
        yOut = wFrame.origin.y;
        wOut = wFrame.size.width;
        hOut = wFrame.size.height;
    }
    
    void getWindowFrame(int& xOut, int& yOut, int& wOut, int& hOut) const
    {
        NSRect wFrame = m_nsWindow.frame;
        xOut = wFrame.origin.x;
        yOut = wFrame.origin.y;
        wOut = wFrame.size.width;
        hOut = wFrame.size.height;
    }
    
    void setWindowFrame(float x, float y, float w, float h)
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            NSRect wFrame = NSMakeRect(x, y, w, h);
            [m_nsWindow setFrame:wFrame display:NO];
        });
    }
    
    void setWindowFrame(int x, int y, int w, int h)
    {
        dispatch_sync(dispatch_get_main_queue(),
        ^{
            NSRect wFrame = NSMakeRect(x, y, w, h);
            [m_nsWindow setFrame:wFrame display:NO];
        });
    }
    
    float getVirtualPixelFactor() const
    {
        return [m_nsWindow backingScaleFactor];
    }
    
    bool isFullscreen() const
    {
        return ([m_nsWindow styleMask] & NSFullScreenWindowMask) == NSFullScreenWindowMask;
    }
    
    void setFullscreen(bool fs)
    {
        if ((fs && !isFullscreen()) || (!fs && isFullscreen()))
            dispatch_sync(dispatch_get_main_queue(),
            ^{
                [m_nsWindow toggleFullScreen:nil];
            });
    }
    
    ETouchType getTouchType() const
    {
        return TOUCH_TRACKPAD;
    }
    
    void waitForRetrace()
    {
        static_cast<GraphicsContextCocoa*>(m_gfxCtx)->waitForRetrace();
    }
    
    uintptr_t getPlatformHandle() const
    {
        return (uintptr_t)m_nsWindow;
    }
    
    IGraphicsCommandQueue* getCommandQueue()
    {
        return m_gfxCtx->getCommandQueue();
    }
    
    IGraphicsDataFactory* getDataFactory()
    {
        return m_gfxCtx->getDataFactory();
    }
    
    IGraphicsDataFactory* getLoadContextDataFactory()
    {
        return m_gfxCtx->getLoadContextDataFactory();
    }
    
};
    
IWindow* _WindowCocoaNew(const SystemString& title, NSOpenGLContext* lastGLCtx)
{
    return new WindowCocoa(title, lastGLCtx);
}
    
}

@implementation WindowCocoaInternal
- (id)initWithBooWindow:(boo::WindowCocoa *)bw title:(const boo::SystemString&)title
{
    self = [self initWithContentRect:[self genFrameDefault]
                           styleMask:NSTitledWindowMask|
                                     NSClosableWindowMask|
                                     NSMiniaturizableWindowMask|
                                     NSResizableWindowMask
                             backing:NSBackingStoreBuffered
                               defer:YES];
    self.title = [[NSString stringWithUTF8String:title.c_str()] autorelease];
    booWindow = bw;
    return self;
}
- (void)setFrameDefault
{
    [self setFrame:[self genFrameDefault] display:NO];
}
- (NSRect)genFrameDefault
{
    NSScreen* mainScreen = [NSScreen mainScreen];
    NSRect scrFrame = mainScreen.frame;
    float width = scrFrame.size.width * 2.0 / 3.0;
    float height = scrFrame.size.height * 2.0 / 3.0;
    return NSMakeRect((scrFrame.size.width - width) / 2.0,
                      (scrFrame.size.height - height) / 2.0,
                      width, height);
}
- (void)close
{
    booWindow->_clearWindow();
    [super close];
}
- (BOOL)acceptsFirstResponder
{
    return YES;
}
- (BOOL)acceptsMouseMovedEvents
{
    return YES;
}
- (NSWindowCollectionBehavior)collectionBehavior
{
    return NSWindowCollectionBehaviorFullScreenPrimary;
}
@end