include: "snakemake_utils.smk"

wildcard_constraints:
    parallel = "\d+"

rule end:
    input:
        final_output

rule permutation:
    input:
        expand(outpath+"perms_{parallel}_solutions.csv", parallel=get_parallel())
    output:
        outpath+'all_perms_unique_solutions.csv'
        outpath+"all_perms_activation_frequency_reactions.csv",
        outputs['permutation']
    run:
        shell("python dexom_python/cluster_utils/solution_compilation.py -s %s -o %s -p %s" % (outpath, outpath+"all_perms_", '"*solutions.csv"'))
        shell("touch %s" % outputs['permutation'])

rule perm:
    input:
        config['model'],
        config['gene_file'],
        config['gene_index']
    output:
        outpath+"perms_{parallel}_solutions.csv"
    run:
        shell("python dexom_python/enum_functions/permutation_functions.py -m %s -g %s -a {params.dist_anneal} -n %s -o %sperms_{wildcards.parallel} -i %s" %
        (config['model'], config['gene_file'], config['enum_iterations'], outpath, str(config['gene_index']))

rule grouped:
    input:
        expand(outpath+"div_enum_g_{parallel}_solutions.csv", parallel=get_parallel())
    output:
        outpath+"all_unique_solutions.csv",
        outpath+"all_activation_frequency_reactions.csv",
        outputs['grouped']
    run:
        shell("python dexom_python/cluster_utils/solution_compilation.py -s %s -o %s -p %s" % (outpath, outpath+"all_", '"*solutions.csv"'))
        shell("touch %s" % outputs['grouped'])

rule grouped_batch:
    input:
        config['model'],
        config['reaction_weights'],
        prevsol
    output:
        outpath + "div_enum_g_{parallel}_solutions.csv"
    params:
        rxn_range = lambda w: str(config['rxn_iterations']*int(w.parallel)) + '_' + str(config['rxn_iterations']*(int(w.parallel)+1)),
        dist_anneal = lambda w: (1 - 1 / (config['parallel_batches'] * 2 * (config['enum_iterations'] / 10))) ** int(w.parallel)
    run:
        shell("python dexom_python/enum_functions/rxn_enum_functions.py -m %s -r %s --range {params.rxn_range} -o %srxn_enum_g_{wildcards.parallel} -p %s %s" %
        (config['model'], config['reaction_weights'], outpath, prevsol, rlstring))
        shell("python dexom_python/enum_functions/diversity_enum_functions.py -m %s -r %s -a {params.dist_anneal} -i %s -o %sdiv_enum_g_{wildcards.parallel} -p %srxn_enum_g_{wildcards.parallel}_fluxes.csv %s -s -1" %
        (config['model'], config['reaction_weights'], config['enum_iterations'], outpath, outpath, fullstring))

rule separate:
    input:
        expand(outpath+"rxn_enum_s_{parallel}_solutions.csv", parallel=get_parallel()),
        expand(outpath+"div_enum_s_{parallel}_solutions.csv", parallel=get_parallel())
    output:
        outpath+"diversity-enum_unique_solutions.csv",
        outpath+"diversity-enum_activation_frequency_reactions.csv",
        outpath+"all_unique_solutions.csv",
        outpath+"all_activation_frequency_reactions.csv",
        outputs['separate']
    run:
        shell("python dexom_python/cluster_utils/solution_compilation.py -s %s -o %s -p %s" % (outpath, outpath+"diversity-enum_", '"div_enum*solutions.csv"'))
        shell("python dexom_python/cluster_utils/solution_compilation.py -s %s -o %s -p %s" % (outpath, outpath+"all_", '"*enum*solutions.csv"'))
        shell("touch %s" % outputs['separate'])

rule separate_div:
    input:
        config['model'],
        config['reaction_weights'],
        outpath+"reaction-enum_unique_solutions.csv"
    output:
        outpath+"div_enum_s_{parallel}_solutions.csv"
    params:
        dist_anneal = lambda w: (1 - 1 / (config['parallel_batches'] * 2 * (config['enum_iterations'] / 10))) ** int(w.parallel),
    shell:
        "python dexom_python/enum_functions/diversity_enum_functions.py -m %s -r %s -a {params.dist_anneal} -i %s -o %sdiv_enum_s_{wildcards.parallel} -p %sreaction-enum_unique_fluxes.csv -s {wildcards.parallel} %s" %
        (config['model'], config['reaction_weights'], config['enum_iterations'], outpath, outpath, fullstring)

rule separate_concat_rxn:
    input:
        expand(outpath+"rxn_enum_s_{parallel}_solutions.csv", parallel=get_parallel())
    output:
        outpath+"reaction-enum_unique_solutions.csv",
        outpath+"reaction-enum_activation_frequency_reactions.csv"
    shell:
        "python dexom_python/cluster_utils/solution_compilation.py -s %s -o %s -p %s" % (outpath, outpath+"reaction-enum_", '"rxn*solutions.csv"')

rule separate_rxn:
    input:
        config['model'],
        config['reaction_weights'],
        prevsol
    output:
        outpath+"rxn_enum_s_{parallel}_solutions.csv"
    params:
        rxn_range = lambda w: str(config['rxn_iterations']*int(w.parallel)) + '_' + str(config['rxn_iterations']*(int(w.parallel)+1))
    shell:
        "python dexom_python/enum_functions/rxn_enum_functions.py -m %s -r %s --range {params.rxn_range} -o %srxn_enum_s_{wildcards.parallel} -p %s %s" %
        (config['model'], config['reaction_weights'], outpath, prevsol, rlstring)

rule concat_solutions:
    input:
        expand(outpath+str(config['approach'])+"_enum_{parallel}_solutions.csv", parallel=get_parallel())
    output:
        outpath+"all_unique_solutions.csv",
        outpath+"all_activation_frequency_reactions.csv",
        outputs[config['approach']]
    run:
        shell("python dexom_python/cluster_utils/solution_compilation.py -s %s -o %s -p %s" % (outpath, outpath, '"*solutions.csv"'))
        shell("touch %s" % outputs[config['approach']])

rule div_enum:
    input:
        config['model'],
        config['reaction_weights'],
        prevsol
    output:
        outpath+"div_enum_{parallel}_solutions.csv"
    params:
        dist_anneal = lambda w: (1 - 1 / (config['parallel_batches'] * 2 * (config['enum_iterations'] / 10))) ** int(w.parallel)
    shell:
        "python dexom_python/enum_functions/diversity_enum_functions.py -m %s -r %s -a {params.dist_anneal} -o %sdiv_enum_{wildcards.parallel} -p %s %s" %
        (config['model'], config['reaction_weights'], outpath, prevsol, fullstring)

rule rxn_enum:
    input:
        config['model'],
        config['reaction_weights'],
        prevsol
    output:
        outpath+"rxn_enum_{parallel}_solutions.csv"
    params:
        rxn_range = lambda w: str(config['enum_iterations']*int(w.parallel)) + '_' + str(config['enum_iterations']*(int(w.parallel)+1))
    shell:
        "python dexom_python/enum_functions/rxn_enum_functions.py -m %s -r %s --range {params.rxn_range} -o %srxn_enum_{wildcards.parallel} -p %s %s" %
        (config['model'], config['reaction_weights'], outpath, prevsol, rlstring)

rule imat:
    input:
        config['model'],
        config['reaction_weights']
    output:
        outpath+"imat_solution.csv"
    shell:
        "python dexom_python/imat_functions.py -m %s -r %s -o %simat_solution" %
        (config['model'], config['reaction_weights'], outpath)
