/*
 * 66-rebuild.c
 *
 * Copyright (c) 2018-2021 Eric Vidal <eric@obarun.org>
 *
 * All rights reserved.
 *
 * This file is part of Obarun. It is subject to the license terms in
 * the LICENSE file found in the top-level directory of this
 * distribution.
 * This file may not be copied, modified, propagated, or distributed
 * except according to the terms contained in the LICENSE file./
 */

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#include <oblibs/log.h>
#include <oblibs/string.h>
#include <oblibs/sastr.h>
#include <oblibs/types.h>
#include <oblibs/directory.h>
#include <oblibs/files.h>

#include <skalibs/stralloc.h>
#include <skalibs/sgetopt.h>
#include <skalibs/djbunix.h>
#include <skalibs/unix-transactional.h>
#include <skalibs/cdb.h>

#include <66/ssexec.h>
#include <66/constants.h>
#include <66/utils.h>
#include <66/db.h>
#include <66/svc.h>
#include <66/tree.h>
#include <66/backup.h>
#include <66/resolve.h>
#include <66/parser.h>

#define USAGE "66-rebuild [ -h ] [ -z ] [ -v verbosity ] [ -l live ] [ -d ] tree(s)"

static stralloc WORKDIR = STRALLOC_ZERO ;
static uint8_t DRYRUN = 0 ;
static char *drun = "dry run do: " ;

static inline void info_help (void)
{
    DEFAULT_MSG = 0 ;

    static char const *help =
"\n"
"options :\n"
"   -h: print this help\n"
"   -z: use color\n"
"   -v: increase/decrease verbosity\n"
"   -l: live directory\n"
"   -d: dry run\n"
"\n"
"if no tree is given, all trees will be processed.\n"
;

    log_info(USAGE,"\n",help) ;
}

static void cleanup(void)
{
    log_flow() ;

    int e = errno ;
    if (WORKDIR.len)
    {
        log_trace(DRYRUN ? drun : "","delete temporary directory: ",WORKDIR.s) ;
        rm_rf(WORKDIR.s) ;
    }
    errno = e ;
}

int tree_is_current(char const *base,char const *treename,uid_t owner)
{
    log_flow() ;

    stralloc sacurr = STRALLOC_ZERO ;
    int current = 0 ;

    if (tree_find_current(&sacurr,base,owner))
    {
        char name[sacurr.len + 1] ;
        if (!ob_basename(name,sacurr.s)) log_dieu_nclean(LOG_EXIT_SYS,&cleanup,"basename of: ",sacurr.s) ;
        current = obstr_equal(treename,name) ;
    }
    stralloc_free(&sacurr) ;
    return current ;
}

int tree_is_enabled(char const *treename)
{
    log_flow() ;

    return tree_cmd_state(VERBOSITY,"-s",treename) ;
}

void tree_allowed(stralloc *list,char const *base, char const *treename)
{
    log_flow() ;

    stralloc sa = STRALLOC_ZERO ;
    size_t treenamelen = strlen(treename), baselen = strlen(base), pos ;
    char tmp[baselen + SS_SYSTEM_LEN + 1 + treenamelen + SS_RULES_LEN + 1] ;

    auto_strings(tmp,base,SS_SYSTEM,"/",treename,SS_RULES) ;

    if (!sastr_dir_get(&sa,tmp,"",S_IFREG))
        log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"get permissions of tree at: ",tmp) ;

    for (pos = 0 ;pos < sa.len; pos += strlen(sa.s + pos) + 1)
    {
        char *suid = sa.s + pos ;
        uid_t uid = 0 ;
        if (!uid0_scan(suid, &uid))
            log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"get uid of: ",suid) ;
        if (pos)
            if (!stralloc_cats(list,",")) log_die_nomem_nclean(&cleanup,"stralloc") ;
        if (!get_namebyuid(uid,list))
            log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"get name of uid: ",suid) ;
    }
    if (!stralloc_0(list)) log_die_nomem_nclean(&cleanup,"stralloc") ;
    log_trace(DRYRUN ? drun : "","allowed user(s) for tree: ",treename," are: ",list->s) ;
    stralloc_free(&sa) ;
}

void tree_contents(stralloc *list,char const *tree,ssexec_t *info)
{
    log_flow() ;

    size_t treelen = strlen(tree), pos ;
    stralloc sa = STRALLOC_ZERO ;
    char solve[treelen + SS_SVDIRS_LEN + SS_RESOLVE_LEN + SS_DB_LEN + SS_SRC_LEN + 1] ;

    ss_resolve_t res = RESOLVE_ZERO ;
    auto_strings(solve,tree,SS_SVDIRS,SS_RESOLVE) ;
    if (!sastr_dir_get(&sa,solve,SS_MASTER + 1,S_IFREG))
        log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"get the service resolve files of: ",tree) ;

    auto_strings(solve,tree,SS_SVDIRS) ;

    for (pos = 0 ;pos < sa.len; pos += strlen(sa.s + pos) + 1)
    {
        char *name = sa.s + pos ;
        int logname = get_rstrlen_until(name,SS_LOG_SUFFIX) ;
        if (logname > 0) continue ;

        if (!ss_resolve_read(&res,solve,name))
            log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"read resolve file of: ",solve,"/",name) ;

        if (res.disen)
            if (!stralloc_catb(list,res.sa.s + res.src,strlen(res.sa.s + res.src) + 1))
                log_diesys_nclean(LOG_EXIT_SYS,&cleanup,"stralloc") ;

        log_trace(DRYRUN ? drun : "","tree: ",info->treename.s," contain service: ",res.sa.s + res.src) ;
    }

    stralloc_free(&sa) ;
}

static int run_cmdline(char const *prog,char const **add,int len,char const *const *envp)
{
    log_flow() ;

    pid_t pid ;
    int wstat ;

    char fmt[UINT_FMT] ;
    fmt[uint_fmt(fmt, VERBOSITY)] = 0 ;

    int m = 4 + len, i = 0, n = 0 ;
    char const *newargv[m] ;
    newargv[n++] = prog ;
    newargv[n++] = "-v" ;
    newargv[n++] = fmt ;
    for (;i<len;i++)
        newargv[n++] = add[i] ;
    newargv[n] = 0 ;

    pid = child_spawn0(newargv[0],newargv,envp) ;
    if (waitpid_nointr(pid,&wstat, 0) < 0)
        log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"wait for: ",newargv[0]) ;
    if (wstat) return 0 ;

    return 1 ;
}

int main(int argc, char const *const *argv,char const *const *envp)
{
    int r ;
    unsigned int nclassic = 0, nlongrun = 0, nbsv = 0 ;
    size_t systemlen, optslen = 5, pos, len ;
    char tree_opts_create[optslen] ;
    char *fdir = 0 ;

    log_color = &log_color_disable ;

    stralloc satree = STRALLOC_ZERO ;
    stralloc allow = STRALLOC_ZERO ;
    stralloc contents = STRALLOC_ZERO ;
    stralloc tree_enabled = STRALLOC_ZERO ;
    ssexec_t info = SSEXEC_ZERO ;

    PROG = "66-rebuild" ;
    {
        subgetopt l = SUBGETOPT_ZERO ;

        for (;;)
        {
            int opt = subgetopt_r(argc,argv, "hzv:l:d", &l) ;

            if (opt == -1) break ;
            switch (opt)
            {
                case 'h' :  info_help(); return 0 ;
                case 'v' :  if (!uint0_scan(l.arg, &VERBOSITY)) log_usage(USAGE) ; break ;
                case 'l' :  if (!stralloc_cats(&info.live,l.arg)) log_die_nomem("stralloc") ;
                            if (!stralloc_0(&info.live)) log_die_nomem("stralloc") ;
                            break ;
                case 'z' :  log_color = !isatty(1) ? &log_color_disable : &log_color_enable ; break ;
                case 'd' :  DRYRUN = 1 ; break ;
                default :   log_usage(USAGE) ;
            }
        }
        argc -= l.ind ; argv += l.ind ;
    }

    info.owner = getuid() ;

    if (!set_ownersysdir(&info.base,info.owner)) log_dieusys(LOG_EXIT_SYS, "set owner directory") ;

    char system[info.base.len + SS_SYSTEM_LEN + 2] ;
    auto_strings(system,info.base.s,SS_SYSTEM,"/") ;
    systemlen = info.base.len + SS_SYSTEM_LEN + 1 ;

    if (!argc)
    {
        if (info.owner)
        {
            /** check if user system dir already exist */
            if (!scan_mode(info.base.s,S_IFDIR)) {
                log_info(DRYRUN ? drun : "","No trees exist yet -- Nothing to do") ;
                goto exit ;
            }
        }
        if (!sastr_dir_get(&satree,system,SS_BACKUP + 1,S_IFDIR))
            log_dieusys(LOG_EXIT_SYS,"get list of trees at: ",system) ;

        if (!satree.len)
        {
            log_info(DRYRUN ? drun : "","No trees exist yet -- Nothing to do") ;
            goto exit ;
        }
    }
    else
    {
        int i = 0 ;
        size_t arglen = 0 ;
        for (;i < argc ; i++)
        {
            arglen = strlen(argv[i]) ;
            char tree[systemlen + arglen + 1] ;
            auto_strings(tree,system,argv[i]) ;
            r = scan_mode(tree,S_IFDIR) ;
            if (r == -1) { errno = EEXIST ; log_diesys(LOG_EXIT_SYS,"conflicting format of: ",tree) ; }
            if (!r) log_die(LOG_EXIT_USER,"tree: ",tree," doesn't exist") ;
            if (!stralloc_catb(&satree,argv[i],strlen(argv[i]) + 1))
                log_die_nomem("stralloc") ;
        }
    }
    /** keep start order of trees */
    if (!file_readputsa(&tree_enabled,system,"state"))
        log_dieusys(LOG_EXIT_SYS,"read contents of file: ",system,"state") ;

    len = satree.len ;
    for (pos = 0 ; pos < len; pos += strlen(satree.s + pos) + 1)
    {
        int dbok = 0 ;

        nclassic = nlongrun = nbsv = 0 ;
        info.base.len = info.tree.len = info.treename.len = 0 ;
        allow.len = WORKDIR.len = contents.len = 0 ;
        auto_strings(tree_opts_create,"-n") ;
        optslen = 2 ;

        if (!auto_stra(&info.tree,satree.s + pos))
            log_die_nomem("stralloc") ;

        set_ssinfo(&info) ;

        char tmp[systemlen + SS_BACKUP_LEN + info.treename.len + SS_SVDIRS_LEN + SS_DB_LEN + 1] ;
        char current[info.livetree.len + 1 + info.treename.len + 9 + 1] ;

        log_info(DRYRUN ? drun : "","save state of tree: ", info.treename.s) ;
        if (tree_is_current(info.base.s,info.treename.s,info.owner))
        {
            log_trace(DRYRUN ? drun : "","tree: ",info.treename.s," is marked current") ;
            auto_string_from(tree_opts_create,optslen,"c") ;
            optslen +=1 ;
        }
        if (tree_is_enabled(info.treename.s) == 1)
        {
            log_trace(DRYRUN ? drun : "","tree: ",info.treename.s," is marked enabled") ;
            auto_string_from(tree_opts_create,optslen,"E") ;
            optslen +=1 ;
        }

        tree_allowed(&allow,info.base.s,info.treename.s) ;

        log_info(DRYRUN ? drun : "","save service(s) list of tree: ", info.treename.s) ;
        tree_contents(&contents,info.tree.s,&info) ;

        dbok = db_ok(info.livetree.s, info.treename.s) ;

        if (dbok)
        {
            fdir = 0 ;

            log_trace(DRYRUN ? drun : "","find current source of live db: ",info.livetree.s,"/",info.treename.s) ;
            r = db_find_compiled_state(info.livetree.s,info.treename.s) ;
            if (r == -1) log_die(LOG_EXIT_SYS,"inconsistent state of: ",info.livetree.s) ;
            if (r == 1) {
                auto_strings(tmp,system,SS_BACKUP + 1,"/",info.treename.s,SS_DB) ;
            }
            else auto_strings(tmp,system,info.treename.s,SS_SVDIRS,SS_DB) ;

            log_trace(DRYRUN ? drun : "","created temporary directory at: /tmp") ;
            fdir = dir_create_tmp(&WORKDIR,"/tmp",info.treename.s) ;
            if (!fdir) log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"create temporary directory") ;

            log_trace(DRYRUN ? drun : "","copy contents of: ",tmp," to: ",WORKDIR.s) ;
            if (!hiercopy(tmp,fdir)) log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"copy: ",tmp," to: ",WORKDIR.s) ;

            char new[WORKDIR.len + 1 + info.treename.len + 1] ;

            auto_strings(current,info.livetree.s,"/",info.treename.s,"/compiled") ;
            auto_strings(new,WORKDIR.s,"/",info.treename.s) ;

            log_info(DRYRUN ? drun : "","update ",info.livetree.s,"/",info.treename.s," to: ",new) ;

            if (!DRYRUN)
                if (!atomic_symlink(new, current, PROG))
                    log_dieusys(LOG_EXIT_SYS,"update: ",current," to: ", new) ;

            if (DRYRUN) cleanup() ;
        }

        /** finally we can destroy the tree and recreate it*/
        // destroy
        {
            char const *t[] = { "-l", info.live.s, "-R", info.treename.s } ;
            if (DRYRUN)
            {
                log_info(drun,"66-tree -l ",info.live.s," -R ",info.treename.s) ;
            }
            else
            {
                if (!run_cmdline(SS_EXTBINPREFIX "66-tree",t,4,envp))
                    log_dieu(LOG_EXIT_SYS,"delete tree: ", info.treename.s) ;
            }
        }
        //create
        {
            char const *t[] = { "-l", info.live.s, tree_opts_create,"-a",allow.s, info.treename.s } ;
            if (DRYRUN)
            {
                log_info(drun,"66-tree -l ",info.live.s," ",tree_opts_create," -a ",allow.s," ",info.treename.s) ;
            }
            else
            {
                if (!run_cmdline(SS_EXTBINPREFIX "66-tree",t,6,envp))
                    log_dieu(LOG_EXIT_SYS,"create tree: ", info.treename.s) ;
            }
        }
        // reorganize the trees start order
        if (tree_enabled.len)
        {
            if (!sastr_split_string_in_nline(&tree_enabled))
                log_dieu(LOG_EXIT_SYS,"split elements") ;
            unsigned int enabled ;
            ssize_t r = sastr_find_element_byname(&tree_enabled,info.treename.s,&enabled) ;
            if (r >= 0)
            {
                char *after_tree = tree_enabled.s + sastr_find_element_byid(&tree_enabled,!enabled ? enabled : enabled - 1) ;
                char const *t[] = { "-S", after_tree, info.treename.s } ;
                if (DRYRUN)
                {
                    log_info(drun,"66-tree -S ",after_tree," ",info.treename.s) ;
                }
                else
                {
                    if (!run_cmdline(SS_EXTBINPREFIX "66-tree",t,3,envp))
                        log_dieu(LOG_EXIT_SYS,"orders the start order of tree: ", info.treename.s) ;
                }
            }
        }
        /* we must reimplement the enable process instead of
         * using directly 66-enable. The 66-enable program will use
         * is own workdir with an empty tree. At call of db_update(),
         * the service already running will be brought down. We don't
         * want this behavior. A nope update is necessary.
         * So remake the things with the enable API */

        if (contents.len)
        {
            stralloc tostart = STRALLOC_ZERO ;
            log_info(DRYRUN ? drun : "","enable service(s) of tree: ",info.treename.s) ;
            if (!DRYRUN)
            {
                auto_strings(tmp,system,info.treename.s,SS_SVDIRS) ;
            }
            else
            {
                WORKDIR.len = 0 ;
                log_trace(drun,"copy: ", info.tree.s,SS_SVDIRS," to a temporary directory") ;
                if (!tree_copy(&WORKDIR,info.tree.s,info.treename.s))
                    log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"create tmp working directory") ;
                /* we need to remove the contain of .resolve directory
                 * The write process will try to read it and obviously it
                 * get a wrong information*/
                auto_strings(tmp,WORKDIR.s,SS_RESOLVE) ;
                log_trace(drun,"remove directory: ", tmp) ;
                if (rm_rf(tmp) < 0) log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"remove: ",tmp) ;
                log_trace(drun,"create directory: ", tmp) ;
                if (!dir_create_parent(tmp,0755))
                    log_dieusys_nclean(LOG_EXIT_SYS,&cleanup,"create directory: ",tmp) ;
                auto_string_from(tmp,0,WORKDIR.s) ;

            }

            start_parser(&contents,&info,&nbsv,1) ;
            start_write(&tostart,&nclassic,&nlongrun,tmp,&gasv,&info,1,0) ;
            /** we don't care about nclassic. Classic service are copies
             * of original and we retrieve the original at the end of the
             * process*/
            if(nlongrun)
            {
                ss_resolve_graph_t graph = RESOLVE_GRAPH_ZERO ;
                r = ss_resolve_graph_src(&graph,tmp,0,1) ;
                if (!r)
                    log_dieu(LOG_EXIT_SYS,"resolve source of graph for tree: ",info.treename.s) ;

                r = ss_resolve_graph_publish(&graph,0) ;
                if (r <= 0)
                {
                    if (r < 0) log_die(LOG_EXIT_USER,"cyclic graph detected") ;
                    log_dieusys(LOG_EXIT_SYS,"publish service graph") ;
                }

                if (!ss_resolve_write_master(&info,&graph,tmp,0))
                    log_dieusys(LOG_EXIT_SYS,"update inner bundle") ;

                ss_resolve_graph_free(&graph) ;
                if (!db_compile(tmp,info.tree.s,info.treename.s,envp))
                    log_dieu(LOG_EXIT_SYS,"compile ",tmp,"/",info.treename.s) ;
            }
            stralloc_free(&tostart) ;
            freed_parser() ;
            genalloc_free(sv_alltype,&gasv) ;

        }

        if (dbok)
        {
            auto_strings(tmp,system,info.treename.s,SS_SVDIRS,SS_DB) ;
            log_info(DRYRUN ? drun : "","update db: ",info.livetree.s,"/",info.treename.s, " to: ",tmp,"/",info.treename.s) ;
            /* Be paranoid here and use db_update instead of atomic_symlink.
             * db_update() allow to make a running test and to see
             * if the db match exactly the same state.
             * We prefer to die in this case instead of leaving an
             * inconsistent state. */
            if (!DRYRUN)
                if (!db_update(tmp,&info,envp))
                    log_dieu(LOG_EXIT_SYS,"update: ",info.livetree.s,"/",info.treename.s," to: ", tmp,"/",info.treename.s) ;
        }

        cleanup() ;

        log_info(DRYRUN ? drun : "","tree: ",info.treename.s," rebuild successfully") ;
    }
    exit:
    stralloc_free(&satree) ;
    stralloc_free(&allow) ;
    stralloc_free(&WORKDIR) ;
    stralloc_free(&contents) ;
    stralloc_free(&tree_enabled) ;
    ssexec_free(&info) ;
    return 0 ;
}