/*
 * This file is part of firk's window manager for x11 (fwm)
 * Copyright (C) 2016-2022 firk <firk@cantconnect.ru>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include "main.h"
#include "cfgparse.h"
#include "config.h"

#define ac_log 0
#define ac_run 1
#define ac_chdir 2
#define ac_setenv 3

struct startup_list {
  unsigned int ln;
  unsigned int type; /* 0=log, 1=shellcmd */
  char const * cmd;
  char const * a2;
};


#define MAX_HOTKEYS 200
#define MAX_STARTUP 200
static struct hotkeys_list hotkeys_list[MAX_HOTKEYS];
static size_t num_hotkeys, over_hotkeys;
static struct startup_list startup_list[MAX_STARTUP];
static size_t num_startup, over_startup;
static char const * userconf; /* NOTE: this variable may contain strdup'ed value as well as literal string constant */
       int startup_errors;

       int TASKBAR_WINHEIGHT = DEFAULT_TASKBAR_WINHEIGHT;
#ifndef DEFAULT_TASKBAR_FONT_NAME
#define DEFAULT_TASKBAR_FONT_NAME NULL
#endif
       char const * TASKBAR_FONT_NAME = DEFAULT_TASKBAR_FONT_NAME;
#ifndef DEFAULT_HOLIDAYS_FILE
#define DEFAULT_HOLIDAYS_FILE NULL
#endif
       char const * HOLIDAYS_FILE = DEFAULT_HOLIDAYS_FILE;

extern struct hotkeys_list * get_hotkeys_list(size_t * count) {
  *count = num_hotkeys;
  return hotkeys_list;
}

extern char const * get_hotkey_by_keycode(unsigned int kc, unsigned int shift) {
  unsigned int n;
  struct hotkeys_list * hk;
  for(hk=hotkeys_list,n=num_hotkeys; n; hk++,n--) if(hk->keycode==kc && hk->shift==shift) return hk->cmd;
  return NULL;
}

static void add_hotkey(unsigned int keysym, unsigned int shift, char const * cmd) {
  size_t n;
  struct hotkeys_list * hk;
  for(n=0,hk=hotkeys_list; n<num_hotkeys; n++,hk++) {
    if(hk->keysym==keysym && hk->shift==shift) { hk->cmd = cmd; return; }
  }
  if(n<MAX_HOTKEYS) {
    hk->keysym = keysym;
    hk->shift = shift;
    hk->cmd = cmd;
    num_hotkeys++;
  } else over_hotkeys++;
}

static void add_startup(unsigned int ln, unsigned int type, char const * cmd, char const * a2) {
  if(num_startup<MAX_STARTUP) {
    startup_list[num_startup].ln = ln;
    startup_list[num_startup].type = type;
    startup_list[num_startup].cmd = cmd;
    startup_list[num_startup].a2 = a2;
    num_startup++;
  } else {
    free((void*)cmd);
    if(a2) free((void*)a2);
    over_startup++;
  }
}

static void clear_startup(void) {
  while(num_startup) {
    num_startup--;
    if(startup_list[num_startup].cmd) free((void*)startup_list[num_startup].cmd);
    if(startup_list[num_startup].a2) free((void*)startup_list[num_startup].a2);
  }
  num_startup = over_startup = 0;
}

static void set_default_config(void) {
  add_hotkey(XK_Escape, 0, OP_CLOSE_WINDOW);
  add_hotkey(XK_F10,    0, OP_KILL_WINDOW);
  add_hotkey(XK_Tab,    0, OP_NEXT_WINDOW);
  add_hotkey(XK_Tab,    ShiftMask, OP_PREV_WINDOW);
  add_hotkey(XK_Tab,    ControlMask, OP_ZPREV_WINDOW);
  add_hotkey(XK_F,      0, OP_TOGGLE_FULL);
  add_hotkey(XK_grave,  0, OP_TOGGLE_ONTOP);
  add_hotkey(XK_T,      0, "xterm");
  add_hotkey(XK_I,      0, "iceweasel");
  add_hotkey(XK_P,      0, "gnome-screenshot -a");
}


static void parse_command(unsigned ln, char * buf) {
  char c;
  char *b0, *b1, *b2;
  char const *arg, *arg1;
  KeySym ks;
  unsigned int shift;
  
  while((c=*buf)==' ' || c=='\t') buf++;
  if(c=='#' || !c) return;
  b0 = buf;
  while((c=*buf) && c!=' ' && c!='\t' && c!='#') buf++;
  *buf++ = 0;
  if(c!=' ' && c!='\t') b1 = "";
  else {
    while((c=*buf)==' ' || c=='\t') buf++;
    b1 = buf;
    while((c=*buf) && c!='#') buf++;
    *buf = 0;
  }
  if(!strcmp(b0,"log")) {
    if(!(arg = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; return; }
    add_startup(ln, ac_log, arg, NULL);
    return;
  }
  if(!strcmp(b0,"run")) {
    if(!(arg = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; return; }
    add_startup(ln, ac_run, arg, NULL);
    return;
  }
  if(!strcmp(b0,"chdir")) {
    if(!(arg = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; return; }
    add_startup(ln, ac_chdir, arg, NULL);
    return;
  }
  if(!strcmp(b0,"setenv")) {
    b2 = b1;
    while((c=*b2) && c!=' ' && c!='\t') b2++;
    if(c) {
      *(b2++) = 0;
      while((c=*b2)==' ' || c=='\t') b2++;
    }
    if(!(arg1 = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; return; }
    if(!(arg = strdup(b2))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; free((void*)arg1); return; }
    add_startup(ln, ac_setenv, arg, arg1);
    return;
  }
  if(!strcmp(b0,"userconf")) {
    if(userconf) { logprint("duplicate 'userconf' option"); startup_errors = 1; return; }
    if(!(userconf = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; return; }
    return;
  }
  if(!strncmp(b0,"hotkey:",7)) {
    b0+=7;
    shift = 0;
    if(!strncmp(b0,"Ctrl",4) && (b0[4]=='-' || b0[4]=='+')) { shift|=ControlMask; b0+=5; }
    if(!strncmp(b0,"Shift",5) && (b0[5]=='-' || b0[5]=='+')) { shift|=ShiftMask; b0+=6; }
    if(!strncmp(b0,"Ctrl",4) && (b0[4]=='-' || b0[4]=='+')) { shift|=ControlMask; b0+=5; }
    if((ks = XStringToKeysym(b0))==NoSymbol) { logprint("unknown keysym in config line %u", ln); startup_errors = 1; return; }
    if(!strcmp(b1,"OP_CLOSE_WINDOW")) arg = OP_CLOSE_WINDOW;
    else if(!strcmp(b1,"OP_KILL_WINDOW")) arg = OP_KILL_WINDOW;
    else if(!strcmp(b1,"OP_TOGGLE_FULL")) arg = OP_TOGGLE_FULL;
    else if(!strcmp(b1,"OP_NEXT_WINDOW")) arg = OP_NEXT_WINDOW;
    else if(!strcmp(b1,"OP_PREV_WINDOW")) arg = OP_PREV_WINDOW;
    else if(!strcmp(b1,"OP_ZPREV_WINDOW")) arg = OP_ZPREV_WINDOW;
    else if(!strcmp(b1,"OP_TOGGLE_ONTOP")) arg = OP_TOGGLE_ONTOP;
    else if(!strcmp(b1,"OP_QUIT")) arg = OP_QUIT;
    else if(!(arg = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; return; }
    add_hotkey(ks, shift, arg);
    return;
  }

  if(!strcmp(b0,"option:TASKBAR_WINHEIGHT")) {
    TASKBAR_WINHEIGHT = strtoul(b1,NULL,0);
    if(TASKBAR_WINHEIGHT<10 || TASKBAR_WINHEIGHT>50) { logprint("invalid option value at config line %u", ln); startup_errors = 1; TASKBAR_WINHEIGHT = DEFAULT_TASKBAR_WINHEIGHT; return; }
    return;
  }
  if(!strcmp(b0,"option:TASKBAR_FONT_NAME")) {
    if(!(TASKBAR_FONT_NAME = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; TASKBAR_FONT_NAME = DEFAULT_TASKBAR_FONT_NAME; return; }
    return;
  }
  if(!strcmp(b0,"option:HOLIDAYS_FILE")) {
    if(!(HOLIDAYS_FILE = strdup(b1))) { logprint("out of memory while reading config line %u", ln); startup_errors = 1; HOLIDAYS_FILE = DEFAULT_HOLIDAYS_FILE; return; }
    return;
  }

  if(!strcmp(b0,"clear-hotkeys")) {
    num_hotkeys = over_hotkeys = 0;
    return;
  }
  if(!strcmp(b0,"clear-startup")) {
    clear_startup();
    return;
  }
  logprint("error in config line %u", ln); startup_errors = 1; return;
}

static int parse_config_fd(int fd) {
  char buf[4000], c;
  unsigned int sz, p, p0, ln;
  int r, skip;
  sz = 0;
  r = 1;
  skip = 0;
  ln = 1;
  while(r) {
    if(sz>=sizeof(buf)) { logprint("config line %u too long, exiting", ln); exit(-1); }
    while((r = read(fd, buf+sz, sizeof(buf)-sz))<0) if(errno!=EINTR) return -1;
    for(p=sz,p0=0,sz+=r; p<sz; p++) {
      c = buf[p];
      if(c=='\n') {
        buf[p] = 0;
        if(skip) skip=0; else parse_command(ln, buf+p0);
        p0 = p+1;
        ln++;
      } else if(!skip && (c>=0 && c!=9 && c<32 || c==127)) { logprint("config line %u contains invalid symbols, skipping it", ln); startup_errors = 1; skip = 1; }
    }
    if(p0) if(sz-=p0) bcopy(buf+p0, buf, sz);
  }
  if(sz) { logprint("config line %u (last) non-terminated, skipping it", ln); startup_errors = 1; }
  return 0;
}




static void run_startup_item(struct startup_list const * S) {
  char const * s;
  switch(S->type) {
  case ac_log:
    logprint("(config) %s", S->cmd);
    return;
  case ac_run:
    system(S->cmd);
    return;
  case ac_chdir:
    if(!(s = parse_str(S->cmd, 1))) { logprint("error parsing chdir argument at line %u", S->ln); exit(-1); }
    else if(chdir(s)<0) { logprint("chdir(%s) error at line %u", s, S->ln); exit(-1); }
    return;
  case ac_setenv:
    if(!(s = parse_str(S->cmd, 0))) { logprint("error parsing setenv argument at line %u", S->ln); exit(-1); }
    else if(setenv(S->a2, s, 1)<0) { logprint("setenv(%s) error at line %u", S->a2, S->ln); exit(-1); }
    return;
  }
}

static int load_config_file(char const * fn, char const * curname, char const * fbname, int may_missing) {
  int fd;
  logprint("loading config file: %s", fn);
  if(fn[0]=='-' && !fn[1]) {
    if(parse_config_fd(0)<0) { logprint("%sconfig read(%s) i/o error, falling back to %s", curname, fn, fbname); return -1; }
  } else {
    if((fd = open(fn, O_RDONLY|O_NOCTTY))<0) {
      if(errno==ENOENT && may_missing) { logprint("%sconfig file \"%s\" does not exist", curname, fn); return -2; }
      logprint("%sconfig open(%s) failed, falling back to %s", curname, fn, fbname); return -1;
    }
    if(parse_config_fd(fd)<0) { logprint("%sconfig read(%s) i/o error, falling back to %s", curname, fn, fbname); close(fd); return -1; }
    close(fd);
  }
  return 0;
}

#ifndef DEFAULT_CONFIG_FILE
#define DEFAULT_CONFIG_FILE NULL
#endif
#ifndef DEFAULT_USERCONFIG_FILE
#define DEFAULT_USERCONFIG_FILE NULL
#endif

extern void load_configs(unsigned int count, char const * const * fns) {
  unsigned int i;
  int r, ok;
  char const * fn;
  
  if(!count || !(fn=*fns) || !*fn) {
    ok = 0;
    if(DEFAULT_CONFIG_FILE && (r=load_config_file(DEFAULT_CONFIG_FILE,"system-wide ","defaults",1))!=-2) {
      if(r<0) { startup_errors=1; goto fallback; }
      ok = 1;
    }
    if(userconf || (userconf=DEFAULT_USERCONFIG_FILE)) {
      if(!(fn = parse_str(userconf,1))) { logprint("error constructing user-local config-file path"); startup_errors=1; }
      else if(*fn) {
        if(!(fn=strdup(fn))) { logprint("error constructing user-local config-file path: out of memory"); startup_errors=1; }
        else {
          r = load_config_file(fn,"user-local ",ok?"system-wide":"defaults",1);
          free((void*)fn);
          if(r==-2) ;
          else if(r<0) {
            startup_errors = 1;
            if(!ok || !DEFAULT_CONFIG_FILE) goto fallback;
            r = load_config_file(DEFAULT_CONFIG_FILE,"system-wide ","defaults",1);
            if(r<0) goto fallback;
            ok = 1;
          } else ok = 1;
        }
      }
    }
    if(!ok) goto defcfg;
  } else {
    if(load_config_file(fn, "", "defaults", 0)<0) goto fallback;
    for(i=1; i<count; i++) if(load_config_file(fns[i], "secondary ", "primary", 0)<0) {
      num_hotkeys = over_hotkeys = 0; clear_startup(); startup_errors = 1;
      if(load_config_file(fn, "", "defaults", 0)<0) goto fallback;
      break;
    }
  }
  if(over_hotkeys) { logprint("too many hotkeys, %u skipped", (unsigned)over_hotkeys); startup_errors = 1; }
  if(over_startup) { logprint("too many startup commands, %u skipped", (unsigned)over_startup); startup_errors = 1; }
  return;
fallback:
  num_hotkeys = over_hotkeys = 0; clear_startup(); startup_errors = 1;
defcfg:
  logprint("using default config"); set_default_config(); return;
}

extern void run_startup(void) {
  unsigned int i;
  for(i=0; i<num_startup; i++) run_startup_item(startup_list+i);
  clear_startup();
}

typedef struct {
  unsigned Y, M, n;
  unsigned char * list;
} t_holidays;

static time_t holidays_list_time;
static t_holidays * holidays_list;
static size_t num_holidays_list;
static int holidays_error;
static t_holidays * holidays_last;
static t_holidays holidays_none;

static void free_holidays_list(t_holidays *l, size_t n) {
  size_t j;
  for(j=0; j<n; j++) free(l[j].list);
  if(n) free(l);
}

static int parse_holiday(unsigned ln, char const * st, t_holidays ** pl, size_t * pn) {
  unsigned Y, M, D, n;
  char c;
  t_holidays * list;
  size_t j, jj;
  unsigned char * ll;

  Y = M = D = 0;
  while(1) {
    c = *(st++);
    if(c<'0' || c>'9') break;
    n = Y*10 + (c-'0');
    if(n<Y) goto err;
    Y = n;
  }
  if(!Y || c!='-') goto err;
  while(1) {
    c = *(st++);
    if(c<'0' || c>'9') break;
    n = M*10 + (c-'0');
    if(n<M) goto err;
    M = n;
  }
  if(M<1 || M>12 || c!='-') goto err;
  while(1) {
    c = *(st++);
    if(c<'0' || c>'9') break;
    n = D*10 + (c-'0');
    if(n<D) goto err;
    D = n;
  }
  if(D<1 || D>31 || c!=' ') goto err;
  c = *(st++);
  if(c<'0' || c>'3' || *st) goto err;
  c = (c=='1');
  list = *pl;
  if(!(j = *pn)) {
    if(!(list = malloc(sizeof(*list)))) goto mem;
    list->Y = Y; list->M = M; list->n = 1;
    if(!(list->list = malloc(2))) { free(list); goto mem; }
    list->list[0] = D; list->list[1] = c;
    *pl = list; *pn = 1;
    return 0;
  }
  if(list[j-1].Y>Y || list[j-1].Y==Y && list[j-1].M>M) {
    logprint("holidays-list line %u not in order, skipping it", ln); return -1;
  }
  if(list[j-1].Y!=Y || list[j-1].M!=M) {
    jj = (j+1)*sizeof(*list);
    if(!jj || jj/sizeof(*list)-1!=j) goto mem;
    if(!(list = realloc(list, jj))) goto mem;
    *pl = list;
    list[j].Y = Y; list[j].M = M; list[j].n = 1;
    if(!(list[j].list = malloc(2))) goto mem;
    list[j].list[0] = D; list[j].list[1] = c;
    *pn = j+1;
    return 0;
  }
  list += j-1;
  if(list->n>=31) {
    logprint("holidays-list line %u - too many entires for smae month, skipping it", ln); return -1;
  }
  if(!(ll = realloc(list->list, (list->n+1)*2))) goto mem;
  list->list = ll;
  ll[list->n*2] = D;
  ll[list->n*2+1] = c;
  list->n++;
  return 0;
err: logprint("holidays-list line %u syntax error, skipping it", ln); return -1;
mem: logprint("out of memory while parsing holidays-list line %u, skipping it", ln); return -1;
}

static int parse_holidays_list_fd(int fd, t_holidays ** pl, size_t * pn) {
  char buf[4000], c;
  unsigned int sz, p, p0, ln;
  int r, skip;

  sz = 0;
  r = 1;
  skip = 0;
  ln = 1;
  while(r) {
    if(sz>=sizeof(buf)) { logprint("holidays-list line %u too long", ln); return -1; }
    while((r = read(fd, buf+sz, sizeof(buf)-sz))<0) if(errno!=EINTR) return -1;
    for(p=sz,p0=0,sz+=r; p<sz; p++) {
      c = buf[p];
      if(c=='\n') {
        buf[p] = 0;
        if(skip) skip=0; else parse_holiday(ln, buf+p0, pl, pn);
        p0 = p+1;
        ln++;
      } else if(!skip && (c>=0 && c!=9 && c<32 || c==127)) { logprint("holidays-list line %u contains invalid symbols, skipping it", ln); skip = 1; }
    }
    if(p0) if(sz-=p0) bcopy(buf+p0, buf, sz);
  }
  if(sz) { logprint("holidays-list line %u (last) non-terminated, skipping it", ln); }
  return 0;
}

extern void check_holidays_file(int force) {
  int fd;
  t_holidays * newlist;
  size_t newn;
  struct stat sb;

  if(!HOLIDAYS_FILE) return;
  while(stat(HOLIDAYS_FILE, &sb)<0) if(errno!=EINTR) {
    logprint("can't stat holidays file, please create it or disable in config: %s", HOLIDAYS_FILE);
    holidays_error = 1;
    return;
  }
  if(!force && sb.st_mtime==holidays_list_time) return;
  if(!holidays_list_time) logprint("loading holidays file: %s", HOLIDAYS_FILE);
  else logprint("reloading holidays file: %s", HOLIDAYS_FILE);
  while((fd = open(HOLIDAYS_FILE, O_RDONLY|O_NOCTTY))<0) if(errno!=EINTR) {
    logprint("can't open holidays file, please create it or disable in config: %s", HOLIDAYS_FILE);
    holidays_error = 1;
    return;
  }
  holidays_list_time = sb.st_mtime;
  newlist = NULL;
  newn = 0;
  if(parse_holidays_list_fd(fd, &newlist, &newn)<0) {
    close(fd);
    free_holidays_list(newlist, newn);
    logprint("error reading or parsing holidays file, please fix it or disable in config: %s", HOLIDAYS_FILE);
    holidays_error = 1;
    return;
  }
  close(fd);
  holidays_last = NULL;
  free_holidays_list(holidays_list, num_holidays_list);
  holidays_list = newlist;
  num_holidays_list = newn;
  holidays_error = 0;
}

static t_holidays * get_holidays_list0(unsigned Y, unsigned M) {
  t_holidays * hl;
  size_t n;
  for(hl=holidays_list,n=0; n<num_holidays_list; n++,hl++) {
    if(hl->Y<Y) continue;
    if(hl->Y==Y) {
      if(hl->M<M) continue;
      if(hl->M==M) return hl;
    }
    break;
  }
  return &holidays_none;
}

extern unsigned char const * get_holidays_list(unsigned Y, unsigned M, size_t * sz) {
  t_holidays * hl;
  hl = get_holidays_list0(Y,M);
  *sz = hl->n;
  return hl->list;
}

extern int get_holiday_state(unsigned Y, unsigned M, unsigned D) {
  unsigned j;
  unsigned char const *l;
  if(!holidays_last || holidays_last->Y!=Y || holidays_last->M!=M) holidays_last = get_holidays_list0(Y,M);
  for(j=holidays_last->n,l=holidays_last->list; j; j--,l+=2) if(l[0]==D) return l[1];
  return -1;
}