#!/usr/bin/env cwl-runner

cwlVersion: v1.0
class: Workflow

doc: |
    This workflow will run OxoG, variantbam, and annotate.
    Run this as `dockstore --script --debug workflow launch --descriptor cwl --local-entry --entry ./oxog_varbam_annotate_wf.cwl --json oxog_varbam_annotat_wf.input.json `

dct:creator:
    foaf:name: "Solomon Shorser"
    foaf:mbox: "solomon.shorser@oicr.on.ca"

requirements:
    - class: SchemaDefRequirement
      types:
          - $import: PreprocessedFilesType.yaml
          - $import: TumourType.yaml
    - class: ScatterFeatureRequirement
    - class: StepInputExpressionRequirement
    - class: MultipleInputFeatureRequirement
    - class: InlineJavascriptRequirement
      expressionLib:
        - { $include: oxog_varbam_annotate_util.js }
        # Shouldn't have to *explicitly* include these but there's
        # probably a bug somewhere that makes it necessary
        - { $include: preprocess_util.js }
        - { $include: vcf_merge_util.js }
    - class: SubworkflowFeatureRequirement

inputs:
    inputFileDirectory:
      type: Directory
    refFile:
      type: File
    out_dir:
      type: string
    normalBam:
      type: File
    snv-padding:
      type: string
    sv-padding:
      type: string
    indel-padding:
      type: string
    refDataDir:
      type: Directory
    minibamName:
      type: string
    vcfdir:
      type: Directory
    # "tumours" is an array of records. Each record contains the tumour ID, BAM
    # file name, and an array of VCFs.
    tumours:
      type:
        type: array
        items: "TumourType.yaml#TumourType"

outputs:
    #oxog_filtered_files:
    #    type: File[]
    #    outputSource: flatten_oxog_output/oxogVCFs
    #    secondaryFiles: "*.tbi"
    minibams:
        type: File[]
        outputSource: gather_minibams/minibams
        secondaryFiles: "*.bai"
    #annotated_files:
    #    type: File[]
    #    outputSource: gather_annotated_vcfs/annotated_vcfs

steps:
    ########################################
    # Preprocessing                        #
    ########################################
    #
    # Execute the preprocessor subworkflow.
    preprocess_vcfs:
      in:
        vcfdir: inputFileDirectory
        ref: refFile
        out_dir: out_dir
        filesToPreprocess:
            source: [ tumours ]
            valueFrom: |
                ${
                    // Put all VCFs into an array.
                    var VCFs = []
                    for (var i in self)
                    {
                        for (var j in self[i].associatedVcfs)
                        {
                            VCFs.push(self[i].associatedVcfs[j])
                        }
                    }
                    return VCFs;
                    //return self[0].associatedVcfs
                }
      run: preprocess_vcf.cwl
      out: [preprocessedFiles]

    get_merged_vcfs:
        in:
            in_record: preprocess_vcfs/preprocessedFiles
        run:
            class: ExpressionTool
            inputs:
                in_record: "PreprocessedFilesType.yaml#PreprocessedFileset"
            outputs:
                merged_vcfs: File[]
            expression: |
                $( { merged_vcfs:  inputs.in_record.mergedVcfs } )
        out: [merged_vcfs]

    get_cleaned_vcfs:
        in:
            in_record: preprocess_vcfs/preprocessedFiles
        run:
            class: ExpressionTool
            inputs:
                in_record: "PreprocessedFilesType.yaml#PreprocessedFileset"
            outputs:
                cleaned_vcfs: File[]
            expression: |
                $( { cleaned_vcfs:  inputs.in_record.cleanedVcfs } )
        out: [cleaned_vcfs]

    get_normalized_vcfs:
        in:
            in_record: preprocess_vcfs/preprocessedFiles
        run:
            class: ExpressionTool
            inputs:
                in_record: "PreprocessedFilesType.yaml#PreprocessedFileset"
            outputs:
                normalized_vcfs: File[]
            expression: |
                $( { normalized_vcfs:  inputs.in_record.normalizedVcfs } )
        out: [normalized_vcfs]

    get_extracted_snvs:
        in:
            in_record: preprocess_vcfs/preprocessedFiles
        run:
            class: ExpressionTool
            inputs:
                in_record: "PreprocessedFilesType.yaml#PreprocessedFileset"
            outputs:
                extracted_snvs: File[]?
            expression: |
                $( { extracted_snvs:  inputs.in_record.extractedSnvs } )
        out: [extracted_snvs]

    filter_merged_snv:
        in:
            in_vcfs: get_merged_vcfs/merged_vcfs
        run:
            class: ExpressionTool
            inputs:
                in_vcfs: File[]
            outputs:
                merged_snv_vcf: File
            expression: |
                $({ merged_snv_vcf: filterFileArray("snv",inputs.in_vcfs) })
        out: [merged_snv_vcf]

    filter_merged_indel:
        in:
            in_vcfs: get_merged_vcfs/merged_vcfs
        run:
            class: ExpressionTool
            inputs:
                in_vcfs: File[]
            outputs:
                merged_indel_vcf: File
            expression: |
                $({ merged_indel_vcf: filterFileArray("indel",inputs.in_vcfs) })
        out: [merged_indel_vcf]

    filter_merged_sv:
        in:
            in_vcfs: get_merged_vcfs/merged_vcfs
        run:
            class: ExpressionTool
            inputs:
                in_vcfs: File[]
            outputs:
                merged_sv_vcf: File
            expression: |
                $({ merged_sv_vcf: filterFileArray("sv",inputs.in_vcfs) })
        out: [merged_sv_vcf]

    ########################################
    # Do Variantbam                        #
    ########################################
    # This needs to be run for each tumour, using VCFs that are merged pipelines per tumour.
    run_variant_bam:
        in:
            in_data:
                source: tumours
            indel-padding: indel-padding
            snv-padding: snv-padding
            sv-padding: sv-padding
            input-snv: filter_merged_snv/merged_snv_vcf
            input-sv: filter_merged_sv/merged_sv_vcf
            input-indel: filter_merged_indel/merged_indel_vcf
            inputFileDirectory: inputFileDirectory
        out: [minibam]
        scatter: [in_data]
        run: ./minibam_sub_wf.cwl

    # Create minibam for normal BAM. It would be nice to figure out how to get this into
    # the main run_variant_bam step that currently only does tumour BAMs.
    run_variant_bam_normal:
        in:
            indel-padding: indel-padding
            snv-padding: snv-padding
            sv-padding: sv-padding
            input-snv: filter_merged_snv/merged_snv_vcf
            input-sv: filter_merged_sv/merged_sv_vcf
            input-indel: filter_merged_indel/merged_indel_vcf
            inputFileDirectory: inputFileDirectory
            input-bam: normalBam
            outfile:
                source: normalBam
                valueFrom: $("mini-".concat(self.basename))
        run: Variantbam-for-dockstore/variantbam.cwl
        out: [minibam]

    # Gather all minibams into a single output array.
    gather_minibams:
        in:
            tumour_minibams: run_variant_bam/minibam
            normal_minibam: run_variant_bam_normal/minibam
        run:
            class: ExpressionTool
            inputs:
                tumour_minibams: File[]
                normal_minibam: File
            outputs:
                minibams: File[]
            expression: |
                $( { minibams: inputs.tumour_minibams.concat(inputs.normal_minibam) } )
        out: [minibams]

    ### Prepare for OxoG!
    # First we need to zip and index the VCFs - the OxoG filter requires them to be
    # zipped and index.
    zip_and_index_files_for_oxog:
        in:
            vcf:
                source: get_cleaned_vcfs/cleaned_vcfs
        scatter: [vcf]
        out: [zipped_file]
        run: zip_and_index_vcf.cwl

    # Gather the appropriate VCFS.
    # All SNVs, and all SNVs extracted from INDELs.
    gather_vcfs_for_oxog:
        in:
            vcf:
                source: [zip_and_index_files_for_oxog/zipped_file]
                valueFrom: |
                    ${
                        var snvs = []
                        for (var i in self)
                        {
                            if (self[i].basename.indexOf("snv") !== -1)
                            {
                                snvs.push(self[i])
                            }
                        }
                        return snvs
                    }
            extractedSNVs:
                source: get_extracted_snvs/extracted_snvs
        run:
            class: ExpressionTool
            inputs:
                vcf: File[]
                extractedSNVs: File[]?
            outputs:
                vcfs: File[]
            expression: |
                $(
                    { vcfs: inputs.vcf.concat(inputs.extractedSNVs) }
                )
        out: [vcfs]


    ########################################
    # Do OxoG Filtering                    #
    ########################################
    #
    # OxoG only runs on SNV VCFs
    run_oxog:
        in:
            in_data:
                source: tumours
            inputFileDirectory: inputFileDirectory
            refDataDir: refDataDir
            vcfsForOxoG: gather_vcfs_for_oxog/vcfs
        out: [oxogVCF]
        scatter: [in_data]
        run: oxog_sub_wf.cwl

    flatten_oxog_output:
        in:
            array_of_arrays: run_oxog/oxogVCF
        run:
            class: ExpressionTool
            inputs:
                array_of_arrays:
                    type: { type: array, items: { type: array, items: File } }
            expression: |
                $(
                    { oxogVCFs: flatten_nested_arrays(inputs.array_of_arrays) }
                )
            outputs:
                oxogVCFs: File[]
        out:
            [oxogVCFs]

    ########################################
    # Do Annotation.                       #
    ########################################
    #
    # we need OxoG filtered files, and minibams (tumour and normal).
    # Then we need to scatter. We can scatter on minibams, and perform all annotations
    # for each minibam at a time.
    run_annotator_snvs:
        in:
            tumourMinibams: run_variant_bam/minibam
            VCFs: flatten_oxog_output/oxogVCFs
            tumour_record:
                source: tumours
            normalMinibam: run_variant_bam_normal/minibam
            variantType:
                default: "SNV"
        out: [ annotated_vcfs ]
        scatter: [tumour_record]
        run: annotator_sub_wf.cwl

    # Annotation must also be performed on INDELs but since INDELs don't get OxoG-filtered,
    # we will use the normalized INDELs.
    run_annotator_indels:
        in:
            tumourMinibams: run_variant_bam/minibam
            VCFs: get_normalized_vcfs/normalized_vcfs
            tumour_record:
                source: tumours
            normalMinibam: run_variant_bam_normal/minibam
            variantType:
                default: "INDEL"
        out: [annotated_vcfs]
        scatter: [tumour_record]
        run: annotator_sub_wf.cwl

    #gather_annotated_vcfs:
    #    in:
    #        annotated_snvs: run_annotator_snvs/annotated_vcfs
    #        annotated_indels: run_annotator_indels/annotated_vcfs
    #    run:
    #        class: ExpressionTool
    #        inputs:
    #            annotated_snvs:
    #                type: { type: array, items: { type: array, items: File } }
    #            annotated_indels:
    #                type: { type: array, items: { type: array, items: File } }
    #        outputs:
    #            annotated_vcfs: File[]
    #        expression: |
    #            $(
    #                { annotated_vcfs: flatten_nested_arrays(inputs.annotated_snvs).concat(flatten_nested_arrays(inputs.annotated_indels)) }
    #            )
    #    out:
    #        [annotated_vcfs]

    # Now run the QA check.
    #qa_check:
    #    in:
    #        tumourMinibams: run_variant_bam/minibam
    #        tumour_record:
    #            source: tumours
    #        normal_bam: normalBam
    #        vcfs: flatten_oxog_output/oxogVCFs
    #        normalMinibam: run_variant_bam_normal/minibam
    #        inputFileDirectory: inputFileDirectory
    #    scatter: [tumour_record]
    #    run:
    #        class: Workflow
    #        inputs:
    #            inputFileDirectory:
    #                type: Directory
    #            tumour_record:
    #                type: "TumourType.yaml#TumourType"
    #            vcfs:
    #                type: File[]
    #            normal_bam:
    #                type: File
    #                secondaryFiles: .bai
    #            tumourMinibams:
    #                type: File[]
    #            normalMinibam:
    #                type: File
    #        steps:
    #            run_qa_check:
    #                in:
    #                    tumour_record: tumour_record
    #                    vcfs: vcfs
    #                    normal_bam: normal_bam
    #                    normal_minibam: normalMinibam
    #                    tumour_minibam:
    #                        source: [tumour_record, tumourMinibams]
    #                        valueFrom: |
    #                            ${
    #                                for (var i in self[1])
    #                                {
    #                                    var tumourMinibam = self[1][i]
    #                                    if (tumourMinibam.basename.indexOf( self[0].bamFileName ) !== -1)
    #                                    {
    #                                        return tumourMinibam
    #                                    }
    #                                }
    #                            }
    #                    tumour_bam:
    #                        source: [inputFileDirectory, tumour_record]
    #                        valueFrom: |
    #                            ${
    #                                return { "class":"File", "location": self[0].location + "/" + self[1].bamFileName }
    #                            }
    #                out: [qa_result]
    #                run: qa_check_subwf.cwl
    #        outputs:
    #            qa_result:
    #                type: File
    #    out:
    #        [qa_result]