#!/usr/bin/env nextflow

nextflow.enable.dsl = 2

// Import a single utility function
include { checkConfigProvided } from 'plugin/nf-core-utils'

// Check if custom config or profile was provided
checkConfigProvided()

workflow {
    log.info "Pipeline started with proper validation!"
}

#!/usr/bin/env nextflow

nextflow.enable.dsl = 2

include { checkConfigProvided; completionSummary } from 'plugin/nf-core-utils'

checkConfigProvided()

workflow {
    log.info "Pipeline processing samples..."
    // Your workflow logic here
}

workflow.onComplete {
    completionSummary(params.monochrome_logs)
}

#!/usr/bin/env nextflow

nextflow.enable.dsl = 2

// Essential utilities for most pipelines
include {
    checkConfigProvided; checkProfileProvided;
    completionSummary; completionEmail;
    paramsSummaryMultiqc; getWorkflowVersion
} from 'plugin/nf-core-utils'

// Advanced features for comprehensive pipelines
include {
    getCitation; autoToolCitationText;
    generateComprehensiveReport
} from 'plugin/nf-core-utils'

#!/usr/bin/env nextflow

include { checkConfigProvided; checkProfileProvided } from 'plugin/nf-core-utils'

// Validate setup before any processing
checkConfigProvided()
checkProfileProvided(args, params.monochrome_logs)

workflow {
    // Now proceed with confidence that setup is correct
    log.info "Configuration validated successfully"
}

workflow.onComplete {
    // CORRECT - These functions work here
    completionSummary(params.monochrome_logs)

    if (params.email) {
        completionEmail(summary_params, params.email, ...)
    }

    if (params.hook_url) {
        imNotification(summary_params, params.hook_url)
    }
}

workflow {
    // WRONG - These functions will fail here
    // completionSummary(params.monochrome_logs)  // Error: session is null
}

process FASTQC {
    output:
    path "*.html", emit: html
    val citation_data, topic: citation

    script:
    // Extract citation for automatic collection
    citation_data = getCitation("${moduleDir}/meta.yml")
    """
    fastqc sample.fastq
    """
}

workflow {
    FASTQC(samples)

    // Collect citations from all processes
    citation_ch = FASTQC.out.citation.collect()

    // Generate formatted citations
    citation_ch.view { citations ->
        def citationText = autoToolCitationText(citations)
        def bibliography = autoToolBibliographyText(citations)
        log.info "Citations: ${citationText}"
    }
}

include { generateComprehensiveReport } from 'plugin/nf-core-utils'

workflow {
    // Your pipeline processes with version and citation collection...

    // Collect versions and citations
    ch_versions = PROCESS1.out.versions.mix(PROCESS2.out.versions).collect()
    ch_citations = PROCESS1.out.citation.mix(PROCESS2.out.citation).collect()
}

workflow.onComplete {
    // Generate comprehensive report
    ch_versions.concat(ch_citations).collect().view { data ->
        def report = generateComprehensiveReport(
            data.findAll { it.topic == 'versions' },  // Topic versions
            [],  // Legacy versions (empty for modern pipelines)
            [],  // Meta file paths (empty for topic-based citations)
            'multiqc_methods.yml'  // Methods template
        )

        // Write report files
        file("${params.outdir}/pipeline_info/software_versions.yml").text = report.versions_yaml
        file("${params.outdir}/pipeline_info/citations.txt").text = report.tool_citations
        file("${params.outdir}/pipeline_info/methods.txt").text = report.methods_description
    }
}

include { softwareVersionsToYAML } from 'plugin/nf-core-utils'

workflow {
    // Collect versions from processes
    ch_versions = Channel.empty()
    ch_versions = ch_versions.mix(FASTQC.out.versions)
    ch_versions = ch_versions.mix(SAMTOOLS.out.versions)

    // Convert to YAML and save
    ch_versions_yaml = softwareVersionsToYAML(ch_versions)

    ch_versions_yaml.collectFile(
        name: 'software_versions.yml',
        storeDir: "${params.outdir}/pipeline_info"
    )
}

// Override detected Nextflow version (useful for testing)
ch_versions_yaml = softwareVersionsToYAML(
    ch_versions,
    nextflowVersion: '24.10.0'
)

// Or use named parameters
ch_versions_yaml = softwareVersionsToYAML(
    softwareVersions: ch_versions,
    nextflowVersion: workflow.nextflow.version
)

workflow {
    // Modern processes emit topic tuples
    MODERN_FASTQC(samples)  // Emits: ['FASTQC', 'fastqc', '0.12.1']

    // Legacy processes emit YAML strings or files
    LEGACY_SAMTOOLS(bams)   // Emits: 'samtools: 1.17'

    // Some processes emit maps
    CUSTOM_PROCESS(data)    // Emits: [tool1: '1.0', tool2: '2.0']

    // Mix all version sources together
    ch_all_versions = Channel.empty()
        .mix(MODERN_FASTQC.out.versions)
        .mix(LEGACY_SAMTOOLS.out.versions)
        .mix(CUSTOM_PROCESS.out.versions)

    // Function handles all types seamlessly!
    ch_versions_yaml = softwareVersionsToYAML(ch_all_versions)

    ch_versions_yaml.collectFile(
        name: 'software_versions.yml',
        storeDir: "${params.outdir}/pipeline_info"
    )
}

workflow.onComplete {
    // Collect versions as a list
    def versionsList = [
        ['FASTQC', 'fastqc', '0.12.1'],
        ['SAMTOOLS', 'samtools', '1.17'],
        'multiqc: 1.15'  // Can mix formats!
    ]

    // Process directly without channel
    def versionsYaml = softwareVersionsToYAML(
        versionsList,
        [nextflowVersion: workflow.nextflow.version]
    )

    // Write to file
    file("${params.outdir}/pipeline_info/software_versions.yml").text = versionsYaml
}

FASTQC:
  fastqc: 0.12.1
SAMTOOLS:
  samtools: 1.17
Software:
  multiqc: 1.15
  python: 3.9.0
Workflow:
  nf-core/mypipeline: v1.0.0
  Nextflow: 24.10.0

#!/usr/bin/env nextflow

nextflow.enable.dsl = 2

// Import essential nf-core utilities
include {
    checkConfigProvided; checkProfileProvided;
    completionSummary; completionEmail; imNotification;
    paramsSummaryMultiqc; getWorkflowVersion;
    getCitation; autoToolCitationText;
    generateComprehensiveReport
} from 'plugin/nf-core-utils'

params.input = null
params.outdir = "./results"

// Validate setup early
checkConfigProvided()
checkProfileProvided(args, params.monochrome_logs)

// Set up workflow metadata
version_str = getWorkflowVersion(workflow.manifest.version, workflow.commitId)

workflow {
    log.info "Starting ${workflow.manifest.name} ${version_str}"

    // Your pipeline processes here...
    Channel.fromPath(params.input)
        | FASTQC
        | SAMTOOLS_VIEW

    // Collect outputs
    ch_versions = FASTQC.out.versions.mix(SAMTOOLS_VIEW.out.versions)
    ch_citations = FASTQC.out.citation.mix(SAMTOOLS_VIEW.out.citation)

    // Generate MultiQC summary
    def summary_params = [
        'Input': params.input,
        'Output': params.outdir,
        'Version': version_str
    ]
    def mqc_yaml = paramsSummaryMultiqc([Pipeline: summary_params])
    Channel.of(mqc_yaml).collectFile(name: 'workflow_summary_mqc.yaml')
}

process FASTQC {
    output:
    path "*.html", emit: html
    path "versions.yml", emit: versions
    val citation_data, topic: citation

    script:
    citation_data = getCitation("${moduleDir}/meta.yml")
    """
    fastqc --version > versions.yml
    fastqc sample.fastq
    """
}

workflow.onComplete {
    // Show completion summary
    completionSummary(params.monochrome_logs)

    // Send notifications if configured
    def summary_params = [
        'Core Options': [
            'runName': workflow.runName,
            'version': version_str,
            'success': workflow.success
        ]
    ]

    if (params.email) {
        completionEmail(summary_params, params.email, params.email_on_fail,
                       params.plaintext_email, params.outdir, params.monochrome_logs, null)
    }

    if (params.hook_url) {
        imNotification(summary_params, params.hook_url)
    }
}

#!/usr/bin/env nextflow
nextflow.enable.dsl = 2

// 1. Import utilities
include { checkConfigProvided; checkProfileProvided; completionSummary } from 'plugin/nf-core-utils'

// 2. Validate configuration early
checkConfigProvided()
checkProfileProvided(args, params.monochrome_logs)

// 3. Set up metadata
version_str = getWorkflowVersion(workflow.manifest.version, workflow.commitId)

// 4. Main workflow
workflow { /* pipeline logic */ }

// 5. Completion handlers
workflow.onComplete { completionSummary(params.monochrome_logs) }

workflow.onComplete {
    // Debug session availability
    log.info "Session: ${nextflow.Nextflow.session != null}"
    log.info "Success: ${workflow.success}"

    // Test basic functions first
    completionSummary(false)  // Force colors off for testing

    log.info "Basic functions working correctly"
}