/*
 * Copyright 2022 Olaf Wintermann
 *
 * Permission is hereby granted, free of charge, to any person obtaining a 
 * copy of this software and associated documentation files (the "Software"), 
 * to deal in the Software without restriction, including without limitation 
 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 * and/or sell copies of the Software, and to permit persons to whom the 
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in 
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
 * DEALINGS IN THE SOFTWARE.
 */

#include "player.h"
#include "main.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/fcntl.h>
#include <spawn.h>
#include <sys/wait.h>
#include <signal.h>
#include <poll.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <pthread.h>

#include "json.h"
#include "utils.h"
#include "settings.h"
#include "playlist.h"

extern char **environ;

#define STR_BUFSIZE 512
#define WID_ARG_BUFSIZE 24

#define PLAYER_POLL_TIMEOUT 500
#define PLAYER_IN_BUFSIZE   8192

static void json_print(JSONValue *value, char *name, int indent);

static void* start_player(void *data);

static void player_io(Player *p);

static void handle_json_rpc_msg(Player *player, JSONValue *v);
static void handle_json_rpc_reqid(Player *player, JSONValue *v, int reqid);
static void handle_json_rpc_event(Player *player, JSONValue *v, JSONValue *event);

void PlayerOpenFile(MainWindow *win) {
    pthread_t tid;
    if(pthread_create(&tid, NULL, start_player, win)) {
        perror("pthread_create");
    }
}

static int prepare_player(Player *player, char *log_arg, char *ipc_arg) {
    // create tmp directory for IPC
    char *player_tmp = NULL;
    char buf[STR_BUFSIZE];
    snprintf(buf, STR_BUFSIZE, "/tmp/uwplayer-%x", rand());
    int mkdir_success = 0;
    for(int t=0;t<5;t++) {
        if(!mkdir(buf, S_IRWXU)) {
            mkdir_success = 1;
            break;
        } else if(errno != EEXIST) {
            break;
        }
    }
    if(!mkdir_success) return 1;
    player_tmp = strdup(buf);
    player->tmp = player_tmp;
    
    // prepare log/ipc args and create log fifo
    int err = 0;
    
    if(snprintf(log_arg, STR_BUFSIZE, "--log-file=%s/%s", player_tmp, "log.fifo") >= STR_BUFSIZE) {
        err = 1;
    }
    if(snprintf(ipc_arg, STR_BUFSIZE, "--input-ipc-server=%s/%s", player_tmp, "ipc.socket") >= STR_BUFSIZE) {
        err = 1;
    }
    
    snprintf(buf, STR_BUFSIZE, "%s/log.fifo", player_tmp);
    if(err || mkfifo(buf, S_IRUSR|S_IWUSR)) {
        rmdir(player_tmp);
        return 1;
    }
    
    return 0;
}

static void* wait_for_process(void *data) {
    Player *player = data;
    int status = 0;
    waitpid(player->process, &status, 0);
    
    printf("waitpid: %d\n", status);

    player->isactive = FALSE;
    player->status = status;
    SetPlayerWindow(0);
    
    return NULL;
}

static int start_player_process(Player *player, MainWindow *win) {
    char log_arg[STR_BUFSIZE];
    char ipc_arg[STR_BUFSIZE];
    
    if(prepare_player(player, log_arg, ipc_arg)) {
        return 1;
    }
    
    char *player_bin = SettingsGetPlayerBin();
    if(!player_bin) {
        fprintf(stderr, "No mpv binary available\n");
        return 1;
    }
    
    // -wid parameter value for embedding the player in the player_widget
    Window wid = XtWindow(win->player_widget);
    char wid_arg[WID_ARG_BUFSIZE];
    if(snprintf(wid_arg, WID_ARG_BUFSIZE, "%lu", wid) >= WID_ARG_BUFSIZE) {
        return 1;
    }
    
    // create player arg list
    char *args[32];
    int ac = 0;
    args[ac++] = player_bin;
    args[ac++] = "-wid";
    args[ac++] = wid_arg;
    //args[ac++] = "--no-terminal";
    args[ac++] = "--player-operation-mode=pseudo-gui";
    args[ac++] = log_arg;
    args[ac++] = ipc_arg;
    args[ac++] = win->file;
    args[ac++] = NULL;
    
    posix_spawn_file_actions_t actions;
    posix_spawn_file_actions_init(&actions);
    
    //posix_spawn_file_actions_adddup2(&actions, pin[0], STDIN_FILENO);
    //posix_spawn_file_actions_adddup2(&actions, pout[1], STDOUT_FILENO);
    
    // start player
    pid_t player_pid;
    if(posix_spawn(&player_pid, player_bin, &actions, NULL, args, environ)) {
        perror("posix_spawn");
        return 1;
    }
    posix_spawn_file_actions_destroy(&actions);
    
    player->process = player_pid;
    player->isactive = TRUE;
    
    pthread_t tid;
    if(pthread_create(&tid, NULL, wait_for_process, player)) {
        perror("pthread_create");
    }
    
    return 0;
}

static int wait_for_ipc(Player *player) {
    char buf[STR_BUFSIZE];
    snprintf(buf, STR_BUFSIZE, "%s/log.fifo", player->tmp); // cannot fail
    
    // open log
    int fd_log = open(buf, O_RDONLY);
    if(fd_log < 0) {
        perror("Cannot open log");
        return 1;
    }
    player->log = fd_log;
    
    // read log until IPC socket is created
    char *scan_str = "Listening to IPC";
    int scan_pos = 0;
    int scan_len = strlen(scan_str);
    int ipc_listen = 0;
    ssize_t r;
    while((r = read(fd_log, buf, STR_BUFSIZE)) > 0) {
        for(int i=0;i<r;i++) {
            char c = buf[i];
            char *s_str = buf+i;
            
            if(scan_pos == scan_len) {
                ipc_listen = 1;
                break;
            }
            
            if(scan_str[scan_pos] == c) {
                scan_pos++;
            } else {
                scan_pos = 0;
            }
        }
        if(ipc_listen) break;
    }
    
    return 0;
}

static int connect_to_ipc(Player *player) {  
    // connect to IPC socket
    int fd_ipc = socket(AF_UNIX, SOCK_STREAM, 0);
    if(fd_ipc < 0) {
        perror("Cannot create IPC socket");
        return 1;
    }
    player->ipc = fd_ipc;
    
    char buf[STR_BUFSIZE];
    snprintf(buf, STR_BUFSIZE, "%s/%s", player->tmp, "ipc.socket"); // cannot fail
    
    struct sockaddr_un ipc_addr;
    memset(&ipc_addr, 0, sizeof(struct sockaddr_un));
    ipc_addr.sun_family = AF_UNIX;
    memcpy(ipc_addr.sun_path, buf, strlen(buf));
    if(connect(fd_ipc, (struct sockaddr *)&ipc_addr, sizeof(ipc_addr)) == -1) {
        perror("Cannot connect to IPC socket");
        return 1;
    }
    
    return 0;
}

static Boolean update_player_window(XtPointer data) {
    MainWindow *win = data;
    WindowUpdate(win);
    return 0;
}

static void* start_player(void *data) {
    MainWindow *win = data;
    
    Player *player = malloc(sizeof(Player));
    memset(player, 0, sizeof(Player));
    
    // start mpv
    if(start_player_process(player, win)) {
        PlayerDestroy(player);
        return NULL;
    } 
    
    // wait until IPC socket is ready
    if(wait_for_ipc(player)) {
        PlayerDestroy(player);
        return NULL;
    }
    //close(player->log);
     
    if(connect_to_ipc(player)) {
        PlayerDestroy(player);
        return NULL;
    }
    
    // set player in main window
    if(win->player) {
        PlayerDestroy(win->player);
    }
    win->player = player;
    
    // update main window
    AppExecProc(update_player_window, win);
    
    // IO
    player_io(player);
    
    return NULL;
}

static void player_io(Player *p) {
    struct pollfd fds[2];
    fds[0].fd = p->ipc;
    fds[0].events = POLLIN;
    fds[0].revents = 0;
    fds[1].fd = p->log;
    fds[1].events = POLLIN;
    fds[1].revents = 0;
    JSONParser *js = json_parser_new();
     
    char buf[PLAYER_IN_BUFSIZE];
    while(p->isactive && (poll(fds, 2, PLAYER_POLL_TIMEOUT) >= 0)) {
        if(fds[0].revents == POLLIN) {
            ssize_t r;
            if((r = read(fds[0].fd, buf, PLAYER_IN_BUFSIZE)) <= 0) {
                break;
            }
            //fwrite(buf, 1, r, stdout);
            fflush(stdout);
            json_parser_fill(js, buf, r);
            
            JSONValue *value;
            int ret;
            while((ret = json_read_value(js, &value)) == 1) {
                handle_json_rpc_msg(p, value);
                json_value_free(value);
            }
            
            if(ret == -1) {
                fprintf(stderr, "JSON-RPC error\n");
                break;
            }
        }
        if(fds[1].revents == POLLIN) {
            // just read to clean the log pipe
            read(fds[1].fd, buf, PLAYER_IN_BUFSIZE);
        }
        
        //char *cmd = "{ \"command\": [\"get_property\", \"playback-time\"], request_id=\"" REQ_ID_PLAYBACK_TIME "\" }\n";
        //write(p->ipc, cmd, strlen(cmd));
    }
    
    
    printf("PlayerEnd: %s\n", strerror(errno));
    fflush(stdout);
}


static void handle_json_rpc_msg(Player *player, JSONValue *v) {
    if(v->type != JSON_OBJECT) return;
      
    JSONValue *request_id_v = json_obj_get(&v->value.object, "request_id");
    JSONValue *event = NULL;
    if(request_id_v && request_id_v->type == JSON_STRING) {
        int request_id = 0;
        if(request_id_v->value.string.length == 2) {
            request_id = 10 * (request_id_v->value.string.string[0] - '0') + (request_id_v->value.string.string[1] - '0');
            handle_json_rpc_reqid(player, v, request_id);
            return;
        }
    } else if ((event = json_obj_get(&v->value.object, "event")) != NULL) {
        handle_json_rpc_event(player, v, event);
    }
    
    //json_print(v, NULL, 0);
}

static Boolean player_widget_set_size(XtPointer data) {
    Player *player = data;
    MainWindow *win = GetMainWindow();
    
    if(!win->adjustWindowSize) {
        return 0;
    }
        
    Dimension win_width, win_height;
    XtVaGetValues(win->window, XmNwidth, &win_width, XmNheight, &win_height, NULL);
    Dimension player_width, player_height;
    XtVaGetValues(win->player_widget, XmNwidth, &player_width, XmNheight, &player_height, NULL);

    Dimension new_width = player->width + win_width - player_width;
    Dimension new_height = player->height + win_height - player_height;
    
    // set window size
    XtVaSetValues(win->window, XmNwidth, new_width, XmNheight, new_height, NULL);
    
    // set window aspect ratio
    XSizeHints hints;
    hints.flags = PAspect;
    hints.min_aspect.x = new_width;
    hints.min_aspect.y = new_height;
    hints.max_aspect.x = new_width;
    hints.max_aspect.y = new_height;
    XSetWMNormalHints(XtDisplay(win->window), XtWindow(win->window), &hints);
    
    return 0;
}



static void player_set_size(Player *player, int width, int height) {
    if(width >= 0) {
        player->width = width;
    }
    if(height >= 0) {
        player->height = height;
    }
    if(player->width > 0 && player->height > 0) {
        AppExecProc(player_widget_set_size, player);
    }
}

static void handle_json_rpc_reqid(Player *player, JSONValue *v, int reqid) {
    JSONValue *data = json_obj_get(&v->value.object, "data");
    if(!data) return;
    
    switch(reqid) {
        case REQ_ID_PLAYBACK_TIME_INT: {
            if(data->type == JSON_NUMBER) {
                player->playback_time = data->value.number.value;
            }
            break;
        }
        case REQ_ID_WIDTH_INT: {
            if(data->type == JSON_INTEGER) {
                player_set_size(player, data->value.integer.value, -1);
            }
            break;
        }
        case REQ_ID_HEIGHT_INT: {
            if(data->type == JSON_INTEGER) {
                player_set_size(player, -1, data->value.integer.value);
            }
            break;
        }
    }
}

static Boolean get_player_window(XtPointer data) {
    Player *p = data;
    MainWindow *win = GetMainWindow();
    
    Widget player_wid = win->player_widget;
    Window root, parent;
    Window *child;
    unsigned int nchild;
    XQueryTree(XtDisplay(player_wid), XtWindow(player_wid), &root, &parent, &child, &nchild);
    if(nchild > 0) {
        p->window = child[0];
        XFree(child);
        
        SetPlayerWindow(p->window);
        XSelectInput(XtDisplay(win->player_widget), p->window, PointerMotionMask);
    }
    
    return 0;
}

#define CURSOR_AUTOHIDE_THRESHOLD_SEC  4

static Boolean hide_cursor(XtPointer data) {
    MainWindow *win = data;
    WindowHidePlayerCursor(win);
    return 0;
}

static void check_hide_cursor(Player *p) {
    MainWindow *win = GetMainWindow();
    if(win->cursorhidden) return;
    
    if(p->playback_time - win->motion_playback_time > CURSOR_AUTOHIDE_THRESHOLD_SEC) {
        AppExecProc(hide_cursor, win);
    }
}

static void handle_json_rpc_event(Player *p, JSONValue *v, JSONValue *event) {
    if(!json_strcmp(event, "property-change")) {
        JSONValue *name = json_obj_get(&v->value.object, "name");
        JSONValue *data = json_obj_get(&v->value.object, "data");
        if(!json_strcmp(name, "playback-time")) {
            if(data && data->type == JSON_NUMBER) {
                p->playback_time = data->value.number.value;
                //printf("playback-time: %f\n", p->playback_time);
                check_hide_cursor(p);
            }
        } else if(!json_strcmp(name, "eof-reached")) {
            if(data && data->type == JSON_LITERAL && data->value.literal.literal == JSON_TRUE) {
                PlayerEOF(p);
            }
        } else if(!json_strcmp(name, "osd-height")) {
            if(data->type == JSON_NUMBER) {
                p->osd_height = data->value.number.value;
            }
        }
    } else if(!p->isstarted && !json_strcmp(event, "playback-restart")) {
        char *cmd = "{ \"command\": [\"observe_property\", 1, \"playback-time\"] }\n"
                    "{ \"command\": [\"observe_property\", 1, \"eof-reached\"] }\n"
                    "{ \"command\": [\"observe_property\", 1, \"osd-height\"] }\n"
                    "{ \"command\": [\"get_property\", \"width\"], request_id=\"" REQ_ID_WIDTH "\" }\n"
                    "{ \"command\": [\"get_property\", \"height\"], request_id=\"" REQ_ID_HEIGHT "\" }\n"
                    "{ \"command\": [\"set_property\", \"keep-open\", true] }\n";
        write(p->ipc, cmd, strlen(cmd));
        p->isstarted = TRUE;
        
        AppExecProc(get_player_window, p);
    }
}

void PlayerDestroy(Player *p) {
    if(p->log >= 0) {
        close(p->log);
    }
    if(p->ipc >= 0) {
        close(p->ipc);
    }
    
    if(p->tmp) {
        free(p->tmp);
    }
    
    if(p->isactive) {
        kill(p->process, SIGTERM);
    }
    
    SetPlayerWindow(0);
    free(p);
}


static void json_print(JSONValue *value, char *name, int indent) {
    if(name) {
        printf("%*s%s: ", indent*4, "", name);
    } else {
        printf("%*s", indent*4, "");
    }
    
    
    switch(value->type) {
        case JSON_OBJECT: {
            printf("{\n");
            
            for(int i=0;i<value->value.object.size;i++) {
                JSONObjValue val = value->value.object.values[i];
                json_print(val.value, val.name, indent+1);
                if(i+1 < value->value.object.size) {
                    printf(",\n");
                } else {
                    printf("\n");
                }
            }
            
            printf("%*s}", indent*4, "");
            break;
        }
        case JSON_ARRAY: {
            printf("[\n");
            
            for(int i=0;i<value->value.object.size;i++) {
                JSONValue *v = value->value.array.array[i];
                json_print(v, NULL, indent+1);
                if(i+1 < value->value.array.size) {
                    printf(",\n");
                } else {
                    printf("\n");
                }
            }
            
            printf("%*s]", indent*4, "");
            break;
        }
        case JSON_STRING: {
            printf("\"%s\"", value->value.string.string);
            break;
        }
        case JSON_INTEGER: {
            printf("%i", (int)value->value.integer.value);
            break;
        }
        case JSON_NUMBER: {
            printf("%f", value->value.number.value);
            break;
        }
        case JSON_LITERAL: {
            char *lit = "NULL";
            switch(value->value.literal.literal) {
                case JSON_NULL: break;
                case JSON_TRUE: lit = "true"; break;
                case JSON_FALSE: lit = "false"; break;
            }
            printf("%s\n", lit);
            break;
        }
    }
    
    if(indent == 0) {
        putchar('\n');
    }
}

static Boolean play_next(XtPointer data) {
    MainWindow *win = GetMainWindow();
    PlayListPlayNext(win, false);    
    return 0;
}

void PlayerEOF(Player *p) {
    MainWindow *win = GetMainWindow();
    if(win->playlist.repeatTrack) {
        char *cmd = "{ \"command\": [\"set_property\", \"playback-time\", 0] }\n";
        write(p->ipc, cmd, strlen(cmd));
        cmd = "{ \"command\": [\"set_property\", \"pause\", false] }\n";
        write(p->ipc, cmd, strlen(cmd));
    } else {
        AppExecProc(play_next, NULL);
    }
}

void PlayerHandleInput(MainWindow *win, Player *p, XmDrawingAreaCallbackStruct *cb) {
    
}