PHContext.m

/*
 * Phoenix is released under the MIT License. Refer to https://github.com/kasper/phoenix/blob/master/LICENSE.md
 */

@import JavaScriptCore;

#import "NSImage+PHExtension.h"
#import "NSScreen+PHExtension.h"
#import "PHAccessibilityObserver.h"
#import "PHApp.h"
#import "PHContext.h"
#import "PHEventHandler.h"
#import "PHGlobalEventMonitor.h"
#import "PHKeyHandler.h"
#import "PHModalWindowController.h"
#import "PHMouse.h"
#import "PHNotificationHelper.h"
#import "PHPathWatcher.h"
#import "PHPhoenix.h"
#import "PHPreferences.h"
#import "PHShebangPreprocessor.h"
#import "PHSpace.h"
#import "PHStorage.h"
#import "PHTaskHandler.h"
#import "PHTimerHandler.h"
#import "PHWindow.h"

@interface PHContext ()

@property JSContext *context;
@property (copy) NSString *primaryConfigurationPath;
@property NSMutableSet<NSString *> *configurationPaths;
@property PHPathWatcher *watcher;
@property PHAccessibilityObserver *observer;
@property PHGlobalEventMonitor *monitor;
@property PHStorage *storage;

@end

@implementation PHContext

#pragma mark - Initialising

- (instancetype) init {

    if (self = [super init]) {
        self.primaryConfigurationPath = [self resolvePrimaryConfigurationPath];
        self.configurationPaths = [NSMutableSet set];
        self.observer = [PHAccessibilityObserver observer];
        self.monitor = [PHGlobalEventMonitor monitor];
        self.storage = [PHStorage storage];
    }

    return self;
}

+ (instancetype) context {

    return [[self alloc] init];
}

#pragma mark - Resetting

- (void) resetConfigurationPaths {

    [self.configurationPaths removeAllObjects];
}

- (void) resetWatcher {

    PHContext * __weak weakSelf = self;

    self.watcher = [PHPathWatcher watcherFor:self.configurationPaths.allObjects handler:^{

        [[weakSelf class] cancelPreviousPerformRequestsWithTarget:weakSelf
                                                         selector:@selector(load)
                                                           object:nil];

        [weakSelf performSelector:@selector(load) withObject:nil afterDelay:0.5];
    }];
}

#pragma mark - Setting up

- (NSString *) resolvePrimaryConfigurationPath {

    static NSArray<NSString *> *primaryConfigurationPaths;

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{

#if DEBUG
        primaryConfigurationPaths = @[ @"~/.phoenix.debug.js",
                                       @"~/Library/Application Support/Phoenix/phoenix.debug.js",
                                       @"~/.config/phoenix/phoenix.debug.js" ];
#else
        primaryConfigurationPaths = @[ @"~/.phoenix.js",
                                       @"~/Library/Application Support/Phoenix/phoenix.js",
                                       @"~/.config/phoenix/phoenix.js" ];
#endif
    });

    // Look for the first existing configuration location
    for (NSString *primaryConfigurationPath in primaryConfigurationPaths) {

        NSString *resolvedPrimaryConfigurationPath = primaryConfigurationPath.stringByResolvingSymlinksInPath;

        if ([[NSFileManager defaultManager] fileExistsAtPath:resolvedPrimaryConfigurationPath]) {
            return resolvedPrimaryConfigurationPath;
        }
    }

    // Use default configuration location
    return primaryConfigurationPaths.firstObject.stringByResolvingSymlinksInPath;
}

- (NSString *) resolvePath:(NSString *)path {

    path = path.stringByResolvingSymlinksInPath;

    // Resolve relative path
    if(![path isAbsolutePath]) {
        NSURL *relativeUrl = [NSURL URLWithString:self.primaryConfigurationPath];
        path = [NSURL URLWithString:path relativeToURL:relativeUrl].absoluteString;
    }

    return path.stringByStandardizingPath;
}

- (void) createConfigurationFile:(NSString *)path {

    NSError *error;
    NSString *directory = path.stringByDeletingLastPathComponent;

    // Ensure configuration directory exists
    [[NSFileManager defaultManager] createDirectoryAtPath:directory
                              withIntermediateDirectories:YES
                                               attributes:nil
                                                    error:&error];
    if (error) {
        NSLog(@"Error: Could not create configuration directory to path “%@”. (%@)", directory, error);
        return;
    }

    BOOL fileCreated = [[NSFileManager defaultManager] createFileAtPath:path
                                                               contents:[@"" dataUsingEncoding:NSUTF8StringEncoding]
                                                             attributes:nil];
    if (!fileCreated) {
        NSLog(@"Error: Could not create configuration file to path “%@”.", path);
        return;
    }

    [PHNotificationHelper deliver:[NSString stringWithFormat:@"Configuration file “%@” was created.", path]];
}

- (void) loadScript:(NSString *)path {

    NSError *error;
    NSString *script = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:&error];

    if (error) {
        script = @"";
        NSLog(@"Error: Could not read file in path “%@” to string. (%@)", path, error);
    }

    NSError *preprocessError;
    script = [PHShebangPreprocessor process:script atPath:path error:&preprocessError];

    if (preprocessError) {
        NSError *underlyingError = preprocessError.userInfo[NSUnderlyingErrorKey];
        NSLog(@"Error: Preprocessing failed. (%@)", underlyingError.localizedFailureReason);
        [PHNotificationHelper deliver:@"Preprocessing failed. Refer to the logs for more information."];
    }

    [self.context evaluateScript:script];
    [self.configurationPaths addObject:path];
}

- (void) setupAPI {

    PHContext * __weak weakSelf = self;

    self.context[@"Phoenix"] = [PHPhoenix withDelegate:self];
    self.context[@"Storage"] = weakSelf.storage;
    self.context[@"Key"] = [PHKeyHandler class];
    self.context[@"Event"] = [PHEventHandler class];
    self.context[@"Timer"] = [PHTimerHandler class];
    self.context[@"Task"] = [PHTaskHandler class];
    self.context[@"Image"] = [NSImage class];
    self.context[@"Modal"] = [PHModalWindowController class];
    self.context[@"Screen"] = [NSScreen class];
    self.context[@"Space"] = [PHSpace class];
    self.context[@"Mouse"] = [PHMouse class];
    self.context[@"App"] = [PHApp class];
    self.context[@"Window"] = [PHWindow class];

    self.context[@"require"] = ^(NSString *path) {

        path = [weakSelf resolvePath:path];

        if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
            NSString *message = [NSString stringWithFormat:@"Require: File “%@” does not exist.", path];
            weakSelf.context.exception = [JSValue valueWithNewErrorFromMessage:message inContext:weakSelf.context];
            return;
        }

        [weakSelf loadScript:path];
    };
}

- (void) setupContext {

    self.context = [[JSContext alloc] initWithVirtualMachine:[[JSVirtualMachine alloc] init]];
    self.context.exceptionHandler = ^(__unused JSContext *context, JSValue *value) {

        NSLog(@"%@ (%@:%@)", value, value[@"line"], value[@"column"]);
        [PHNotificationHelper deliver:@"Exception raised. Refer to the logs for more information."];
    };

    [self setupAPI];
    [self loadScript:[[NSBundle mainBundle] pathForResource:@"lodash.min" ofType:@"js"]];
    [self loadScript:[[NSBundle mainBundle] pathForResource:@"phoenix.min" ofType:@"js"]];
    [self loadScript:self.primaryConfigurationPath];
}

#pragma mark - PHContextDelegate

- (void) load {

    [[PHPreferences sharedPreferences] reset];
    [self resetConfigurationPaths];

    // No configuration file found, create one for the user
    if (![[NSFileManager defaultManager] fileExistsAtPath:self.primaryConfigurationPath]) {
        [self createConfigurationFile:self.primaryConfigurationPath];
    }

    [self setupContext];
    [self resetWatcher];

    NSLog(@"Context loaded.");
}

- (void) shouldTerminate:(void (^)(void))terminate {

    if (![self.storage isPersisting]) {
        terminate();
        return;
    }

    // Wait until storage is persisted
    [[NSNotificationCenter defaultCenter] addObserverForName:PHStorageDidPersistNotification
                                                      object:nil
                                                       queue:nil
                                                  usingBlock:^(__unused NSNotification *notification) {
        terminate();
    }];
}

@end