useMalwareAnalysis.js

import { ref, computed, onUnmounted } from 'vue'
import { uploadFiles, predictFiles } from '@/api'

function isAllowedExeFile(file) {
  return file.name.toLowerCase().endsWith('.exe')
}

export function useMalwareAnalysis() {
  const files = ref([])
  const uploadError = ref(null)
  const isProcessing = ref(false)
  const progress = ref(0)
  const statusMessage = ref('')
  const results = ref([])
  const activeFileIndex = ref(0)
  let phaseTimers = []

  function clearPhaseTimers() {
    phaseTimers.forEach(clearTimeout)
    phaseTimers = []
  }

  onUnmounted(() => {
    clearPhaseTimers()
  })

  function addFiles(rawFiles) {
    uploadError.value = null
    const arr = Array.from(rawFiles)
    const allowed = arr.filter(isAllowedExeFile)
    const rejectedCount = arr.length - allowed.length

    if (!allowed.length) {
      if (rejectedCount > 0) {
        uploadError.value = 'Only Windows PE (.exe) executables are accepted.'
      }
      return
    }

    if (rejectedCount > 0) {
      uploadError.value = `${rejectedCount} file(s) skipped — only .exe is supported.`
    }

    for (const f of allowed) {
      const dup = files.value.some((x) => x.name === f.name && x.size === f.size)
      if (!dup) files.value.push(f)
    }
  }

  function removeFile(index) {
    files.value.splice(index, 1)
    if (!files.value.length) {
      results.value = []
      activeFileIndex.value = 0
    }
  }

  function schedulePhase(ms, fn) {
    const id = setTimeout(fn, ms)
    phaseTimers.push(id)
    return id
  }

  async function runAnalysis() {
    if (!files.value.length || isProcessing.value) return

    uploadError.value = null
    isProcessing.value = true
    results.value = []
    progress.value = 8
    statusMessage.value = 'Parsing binary structure...'

    clearPhaseTimers()
    schedulePhase(350, () => {
      progress.value = 22
      statusMessage.value = 'Vectorizing byte stream to image tensor...'
    })
    schedulePhase(750, () => {
      progress.value = 38
      statusMessage.value = 'Preparing CNN inference graph...'
    })

    try {
      await uploadFiles(files.value)
      progress.value = 48
      statusMessage.value = 'Running convolutional classifier...'

      const response = await predictFiles(files.value)
      clearPhaseTimers()

      progress.value = 82
      statusMessage.value = 'Aggregating threat score...'
      results.value = response.data.results || []
      activeFileIndex.value = 0

      await new Promise((r) => setTimeout(r, 280))
      progress.value = 100
      const maxScore = Math.max(0, ...results.value.map((r) => r.prediction ?? 0))
      statusMessage.value =
        maxScore >= 0.5
          ? 'Classification complete — elevated malware probability'
          : 'Classification complete — within benign threshold'
    } catch (err) {
      console.error(err)
      clearPhaseTimers()
      uploadError.value =
        err.response?.data?.detail ||
        err.message ||
        'Analysis failed. Check that the API is reachable and the sample is a valid PE executable.'
      statusMessage.value = ''
      results.value = []
    } finally {
      setTimeout(() => {
        isProcessing.value = false
        progress.value = 0
        if (results.value.length) {
          statusMessage.value = 'Ready'
        } else if (!uploadError.value) {
          statusMessage.value = ''
        }
      }, 500)
    }
  }

  const activeResult = computed(() => {
    if (!results.value.length) return null
    const i = Math.min(activeFileIndex.value, results.value.length - 1)
    return results.value[i]
  })

  const activeFile = computed(() => {
    if (!files.value.length) return null
    const i = Math.min(activeFileIndex.value, files.value.length - 1)
    return files.value[i]
  })

  return {
    files,
    uploadError,
    isProcessing,
    progress,
    statusMessage,
    results,
    activeFileIndex,
    activeResult,
    activeFile,
    addFiles,
    removeFile,
    runAnalysis,
  }
}