activateDaffodilDebug.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

'use strict'

import * as fs from 'fs'
import * as path from 'path'
import * as vscode from 'vscode'
import * as infoset from '../infoset'
import * as launchWizard from '../launchWizard/launchWizard'
import * as dfdlLang from '../language/dfdl'
import * as dfdlExt from '../language/semantics/dfdlExt'
import * as dataEditClient from '../dataEditor'
import * as tdmlEditor from '../tdmlEditor'
import * as rootCompletion from '../rootCompletion'
import { tmpdir } from 'os'
import JSZip from 'jszip'
import { rm } from 'node:fs/promises'
import { getTunables } from './extension'

import {
  CancellationToken,
  DebugConfiguration,
  ProviderResult,
  WorkspaceFolder,
} from 'vscode'
import { getDataFileFromFolder, getDebugger } from '../daffodilDebugger'
import { getConfig, getCurrentConfig, getTDMLTestCaseItems } from '../utils'
import { FileAccessor } from './daffodilRuntime'
import { TDMLConfig } from '../classes/tdmlConfig'
import { handleDebugEvent } from './daffodilEvent'
import { InlineDebugAdapterFactory } from './extension'
import {
  appendTestCase,
  readTDMLFileContents,
  getTmpTDMLFilePath,
  copyTestCase,
  TMP_TDML_FILENAME,
} from '../tdmlEditor/utilities/tdmlXmlUtils'
import xmlFormat from 'xml-formatter'
import { CommandsProvider } from '../views/commands'
import * as daffodilDebugErrors from './daffodilDebugErrors'
import { TDMLProvider } from '../tdmlEditor/TDMLProvider'
import { getTestCaseDisplayData } from '../tdmlEditor/utilities/tdmlXmlUtils'

export const outputChannel: vscode.OutputChannel =
  vscode.window.createOutputChannel('Daffodil')

async function createDirectory(directoryPath: string): Promise<void> {
  try {
    await fs.promises.mkdir(directoryPath, { recursive: true })
    console.log(`Directory created successfully at ${directoryPath}`)
  } catch (error) {
    console.error(`Error creating directory:`, error)
    throw error
  }
}

async function copyFileAsync(src: string, dest: string): Promise<void> {
  try {
    // Ensure directory exists first
    await fs.promises.mkdir(path.dirname(dest), { recursive: true })

    await fs.promises.copyFile(src, dest)
    console.log(`'${src}' was copied to '${dest}'`)
  } catch (err) {
    console.error('Error copying file:', err)
    // Propagate the error so callers awaiting this function observe failures
    throw err
  }
}

/** Method to file path for schema and data
 * Details:
 *   Required so that the vscode api commands:
 *     - extension.dfdl-debug.getSchemaName
 *     - extension.dfdl-debug.getDataName
 *   can be sent a file instead of always opening up a prompt.
 *   Always makes it so the vscode api commands above are able
 *   to be tested inside of the test suite
 */
async function getFile(fileRequested, label, title) {
  let file = ''

  if (fileRequested && fs.existsSync(fileRequested)) {
    file = fileRequested
  } else if (fileRequested && !fs.existsSync(fileRequested)) {
    file = ''
  } else {
    file = await vscode.window
      .showOpenDialog({
        canSelectMany: false,
        openLabel: label,
        canSelectFiles: true,
        canSelectFolders: false,
        title: title,
      })
      .then((fileUri) => {
        if (fileUri && fileUri[0]) {
          let path = fileUri[0].fsPath

          return normalizePath(path)
        }

        return ''
      })
  }

  return file
}

// Method to normalize the drive letter in a Windows path to a capital letter
// Even when using Windows, when sending a path to the backend that will be used
// to determine the source file for breakpoints/debugging, it must be case-sensitive
function normalizePath(path: string): string {
  if (
    process.platform === 'win32' &&
    path.length > 2 &&
    path.charCodeAt(0) > 97 &&
    path.charCodeAt(0) <= 122 &&
    path.charAt(1) === ':'
  )
    return path.charAt(0).toUpperCase() + path.slice(1)

  return path
}

/**
 * Configures the file path string of an intended TDML save file if the
 * extension is malformed.
 * @param pathStr
 * @returns file path string with a valid TDML file extension.
 */
function validateTDMLFilePath(pathStr: string): string {
  // Create capture groups for the path
  // Capture Group 2 will be all valid extensions potentially chained at the end of the path
  // Capture Group 1 will be the rest of the filename (before the valid extensions)
  const matches = pathStr.match(/(^.*?)((\.tdml|\.tdml\.xml)*)$/i)
  if (matches) {
    // We want to grab the first valid extension found from the previous regex's Capture Group 2
    //    and append that to the filename with TDML extensions stripped (previous regex's Capture Group 1)
    const extMatches = matches[2].match(/^\.tdml.xml|^\.tdml/i)
    return extMatches ? matches[1] + extMatches : matches[1] + '.tdml'
  }
  return pathStr + '.tdml'
}

/** Method to show dialog to save TDML file
 * Details:
 *   Required so that the vscode api commands:
 *     - extension.dfdl-debug.getValidatedTDMLCopyPath
 *   can be sent a file instead of always opening up a prompt.
 */
async function showTDMLSaveDialog(fileRequested, label, title) {
  let file = await vscode.window.showSaveDialog({
    saveLabel: label,
    title: title,
    filters: {
      TDML: ['tdml', 'tdml.xml'],
    },
    defaultUri: fileRequested,
  })
  if (!file) {
    vscode.window.showErrorMessage('No output TDML filename provided')
    return
  }
  return validateTDMLFilePath(normalizePath(file.fsPath))
}

// Function for setting up the commands for Run and Debug file
async function createDebugRunFileConfigs(
  resource: vscode.Uri,
  runOrDebug: String,
  tdmlAction: string | undefined,
  runLast = false
) {
  let targetResource: vscode.Uri | undefined = resource
  let noDebug = runOrDebug === 'run'

  if (!targetResource) {
    if (vscode.window.activeTextEditor) {
      targetResource = vscode.window.activeTextEditor.document.uri
    } else {
      const tdmlUri = TDMLProvider.getDocumentUri()
      if (tdmlUri) {
        targetResource = tdmlUri
      }
    }
  }

  if (targetResource) {
    const normalizedResource = normalizePath(targetResource.fsPath)

    let infosetFile = `${
      path.basename(normalizedResource).split('.')[0]
    }-infoset.xml`
    vscode.window.showInformationMessage(infosetFile)

    let currentConfig = getCurrentConfig()

    if (runLast && currentConfig) {
      vscode.debug.startDebugging(undefined, currentConfig, {
        noDebug: noDebug,
      })
    } else {
      var tdmlConfig: TDMLConfig | undefined = undefined
      var newData: string | undefined = undefined
      var newSchema: string | undefined = normalizedResource

      if (tdmlAction) {
        tdmlConfig = { action: tdmlAction }

        if (tdmlAction === 'execute') {
          tdmlConfig.path = normalizedResource
          newData = undefined
          newSchema = undefined
        }
      }

      const config = getConfig({
        name: 'Run File',
        request: 'launch',
        type: 'dfdl',
        schema: {
          path: newSchema,
          rootName: null,
          rootNamespace: null,
        },
        data: newData,
        infosetFormat: 'xml',
        infosetOutput: {
          type: 'file',
          path: '${workspaceFolder}/' + infosetFile,
        },
        ...(tdmlConfig && { tdmlConfig: tdmlConfig }),
      })

      vscode.debug.startDebugging(undefined, config, { noDebug: noDebug })
    }
  }
}

function setupViews(context: vscode.ExtensionContext) {
  new CommandsProvider().register(context)
}
export function activateDaffodilDebug(
  context: vscode.ExtensionContext,
  factory?: vscode.DebugAdapterDescriptorFactory
) {
  setupViews(context)

  context.subscriptions.push(
    vscode.commands.registerCommand('getContext', () => context)
  )
  context.subscriptions.push(
    vscode.commands.registerCommand(
      'extension.dfdl-debug.runEditorContents',
      (resource: vscode.Uri) => {
        createDebugRunFileConfigs(resource, 'run', undefined)
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.debugEditorContents',
      (resource: vscode.Uri) => {
        createDebugRunFileConfigs(resource, 'debug', undefined)
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.debugLastEditorContents',
      (resource: vscode.Uri) => {
        createDebugRunFileConfigs(resource, 'debug', undefined, true)
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.appendTDML',
      async (resource: vscode.Uri) => {
        if (!fs.existsSync(getTmpTDMLFilePath())) {
          vscode.window.showErrorMessage(
            `TDML ERROR: Test suite not found. Ensure that the TDML action is set to "generate" for your DFDL debugging launch configuration before appending.`
          )
          console.error(
            `TDML ERROR: Test suite not found. ${TMP_TDML_FILENAME} was not found in ${tmpdir()} for Append TDML operation.`
          )
          return
        }

        let targetResource = resource

        if (!targetResource) {
          if (vscode.window.activeTextEditor) {
            targetResource = vscode.window.activeTextEditor.document.uri
          } else {
            const tdmlUri = TDMLProvider.getDocumentUri()
            if (tdmlUri) {
              targetResource = tdmlUri
            }
          }
        }
        if (targetResource) {
          appendTestCase(getTmpTDMLFilePath(), targetResource.fsPath)
            .then((appendedBuffer) => {
              fs.writeFileSync(targetResource.fsPath, xmlFormat(appendedBuffer))
            })
            .catch((reason) => {
              // Not sure if we need to do something different/more here
              console.log(reason)
            })
        }
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.executeTDML',
      (resource: vscode.Uri) => {
        createDebugRunFileConfigs(resource, 'debug', 'execute')
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.createTDML',
      async (_) => {
        if (!fs.existsSync(getTmpTDMLFilePath())) {
          vscode.window.showErrorMessage(
            `TDML ERROR: Test suite not found. Ensure that the TDML action is set to "generate" for your DFDL debugging launch configuration before copying.`
          )
          console.error(
            `TDML ERROR: Test suite not found. ${TMP_TDML_FILENAME} was not found in ${tmpdir()} for Copy TDML operation.`
          )
          return
        }

        // Ask for destination path
        // Copy file in /tmp to destination path
        // TDMLConfig.path should not be used here because that only matters when sending to the server
        // We could make it so that if someone wants to specify the path and set the action to 'copy', but
        //   that doesn't make a whole lot of sense.
        let targetResource = await vscode.commands.executeCommand(
          'extension.dfdl-debug.getValidatedTDMLCopyPath'
        )

        // Is there a better way of error checking this?
        if (targetResource) {
          copyTestCase(
            getTmpTDMLFilePath(),
            targetResource as unknown as string
          )
            .then((copiedBuffer) => {
              fs.writeFileSync(
                targetResource as unknown as string,
                xmlFormat(copiedBuffer)
              )
            })
            .catch((reason) => {
              // Not sure if we need to do something different/more here
              console.log(reason)
            })
        }
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.zipTDML',
      async (resource: vscode.Uri) => {
        let targetResource: vscode.Uri | undefined = resource
        if (vscode.window.activeTextEditor) {
          targetResource = vscode.window.activeTextEditor.document.uri
        } else {
          const tdmlUri = TDMLProvider.getDocumentUri()
          if (tdmlUri) {
            targetResource = tdmlUri
          }
        }

        const resolvedResource = targetResource

        // create temp zip folder
        let tmpDir = path.dirname(getTmpTDMLFilePath())
        const zipDir = path.posix.join(tmpDir, '_zipdir')
        await createDirectory(zipDir)

        // copy TDML file to zip folder
        await copyFileAsync(
          resolvedResource.fsPath,
          path.posix.join(zipDir, path.basename(resolvedResource.fsPath))
        )

        // read TDML file to see what files are required...
        await readTDMLFileContents(
          path.posix.join(zipDir, path.basename(resolvedResource.fsPath))
        ).then(async (xmlBuffer) => {
          await getTestCaseDisplayData(xmlBuffer).then(
            async (testSuiteData) => {
              // Use for..of so we can await async operations (createDirectory, copies, etc.)
              for (const testCase of testSuiteData.testCases) {
                // create subdir for testcase and wait for it to complete
                const testCaseDir = path.posix.join(
                  zipDir,
                  testCase.testCaseName
                )
                await createDirectory(testCaseDir)
                // copy schema file
                let xsdFile = testCase.testCaseModel
                let xsdFileSrc = path.posix.join(
                  path.dirname(resolvedResource.fsPath),
                  xsdFile
                )
                let xsdFileDest = path.posix.join(
                  testCaseDir,
                  path.basename(xsdFile)
                )
                await copyFileAsync(xsdFileSrc, xsdFileDest)

                // edit path in copied TDML file
                let updatedBuffer = xmlBuffer.replace(
                  `model="${xsdFile}"`,
                  `model="${path.posix.join(testCase.testCaseName, path.basename(xsdFile))}"`
                )
                xmlBuffer = updatedBuffer

                // copy data file
                for (const dataDocuments of testCase.dataDocuments) {
                  const dataFile = path.basename(dataDocuments.trim())
                  const dataFileSrc = path.posix.join(
                    path.dirname(resolvedResource.fsPath),
                    dataDocuments.trim()
                  )
                  const dataFileDest = path.posix.join(
                    testCaseDir,
                    path.basename(dataFile)
                  )
                  await copyFileAsync(dataFileSrc, dataFileDest)

                  // edit path in copied TDML file
                  xmlBuffer = xmlBuffer.replace(
                    dataDocuments.trim(),
                    path.posix.join(testCase.testCaseName, dataFile)
                  )
                }
                // copy infoset files (await each copy)
                for (const dfdlInfosets of testCase.dfdlInfosets) {
                  const infoFile = path.basename(dfdlInfosets.trim())
                  const infoSrc = path.posix.join(
                    path.dirname(resolvedResource.fsPath),
                    dfdlInfosets.trim()
                  )
                  const infoDest = path.posix.join(
                    testCaseDir,
                    path.basename(dfdlInfosets.trim())
                  )
                  await copyFileAsync(infoSrc, infoDest)

                  // edit path in copied TDML file
                  xmlBuffer = xmlBuffer.replace(
                    dfdlInfosets.trim(),
                    path.posix.join(testCase.testCaseName, infoFile)
                  )
                }
              }
            }
          )
          // write updated info back to TDML file
          try {
            // Synchronously writes data to a file, replacing it if it already exists
            fs.writeFileSync(
              path.posix.join(zipDir, path.basename(resolvedResource.fsPath)),
              xmlBuffer,
              { encoding: 'utf8' }
            )
            console.log('Updated schema file written successfully')
          } catch (err) {
            console.error('Error writing updated schema file:', err)
          }
        })

        // zip folders
        const zip = new JSZip()

        // Add the folder content recursively
        console.log('adding folder to zip')
        addFolderToZip(zipDir, zip)

        // Generate, save, and then clean up
        let targetZip = targetResource.fsPath.replace(/tdml$/, 'tdml.zip')
        try {
          const content = await zip.generateAsync({ type: 'nodebuffer' })
          fs.writeFileSync(targetZip, content)
          console.log(`Zip file written successfully: '${targetZip}'`)
          vscode.window.showInformationMessage(
            `Zip file successfully created: '${targetZip}'`
          )
          await rm(zipDir, { recursive: true, force: true })
          console.log(`Temp directory successfully removed: '${zipDir}'`)
        } catch (err) {
          console.error(
            `Error while creating zip file '${targetZip}' or deleting temp directory '${zipDir}': ${err}`
          )
          vscode.window.showErrorMessage(
            `Failed to create zip file: '${targetZip}'`
          )
        }
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.toggleFormatting',
      (_) => {
        const ds = vscode.debug.activeDebugSession
        if (ds) {
          ds.customRequest('toggleFormatting')
        }
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.getSchemaName',
      async (fileRequested = null) => {
        // Open native file explorer to allow user to select data file from anywhere on their machine
        const retVal = await getFile(
          fileRequested,
          'Select DFDL schema to debug',
          'Select DFDL schema to debug'
        )

        if (!retVal)
          vscode.window.showInformationMessage(
            'Invalid DFDL schema path selected'
          )

        return retVal
      }
    ),
    vscode.commands.registerCommand(
      'extension.dfdl-debug.getDataName',
      async (fileRequested = null) => {
        // Open native file explorer to allow user to select data file from anywhere on their machine
        const retVal = await getFile(
          fileRequested,
          'Select input data file to debug',
          'Select input data file to debug'
        )

        if (!retVal)
          vscode.window.showInformationMessage(
            'Invalid data file path selected'
          )

        return retVal
      }
    ),
    vscode.commands.registerCommand('extension.dfdl-debug.showLogs', () => {
      outputChannel.show(true)
    })
  )

  context.subscriptions.push(
    vscode.commands.registerCommand(
      'extension.dfdl-debug.getValidatedTDMLPath',
      async (fileRequested = null) => {
        // Open native file explorer to allow user to select data file from anywhere on their machine
        const retVal = await getFile(
          fileRequested,
          'Select TDML File',
          'Select TDML File'
        )

        if (!retVal)
          vscode.window.showInformationMessage('Invalid TDML Path selected')

        return retVal
      }
    )
  )

  context.subscriptions.push(
    vscode.commands.registerCommand(
      'extension.dfdl-debug.getValidatedTDMLCopyPath',
      async (fileRequested = null) => {
        // Open native file explorer to allow user to select data file from anywhere on their machine
        if (fileRequested && fs.existsSync(fileRequested)) {
          return fileRequested
        } else if (fileRequested && !fs.existsSync(fileRequested)) {
          return ''
        } else {
          return await showTDMLSaveDialog(
            fileRequested,
            'Save TDML File',
            'Save TDML File'
          )
        }
      }
    )
  )

  context.subscriptions.push(
    vscode.commands.registerCommand(
      'extension.dfdl-debug.getTDMLName',
      async (tdmlConfigPath) => {
        // get test case name options for dropdown
        const test_case_names: string[] = getTDMLTestCaseItems(tdmlConfigPath)

        if (test_case_names.length == 0) {
          vscode.window.showInformationMessage(
            'No test cases found in TDML file.'
          )
          return
        }

        // Await showQuickPick directly and return the result
        const retVal = await vscode.window.showQuickPick(test_case_names, {
          placeHolder: 'Test Case Name',
        })

        if (!retVal)
          vscode.window.showInformationMessage('Invalid TDML Name selected')

        return retVal
      }
    )
  )

  // register a configuration provider for 'dfdl' debug type
  const provider = new DaffodilConfigurationProvider(context)
  context.subscriptions.push(
    // register a configuration provider for 'dfdl' debug type
    vscode.debug.registerDebugConfigurationProvider('dfdl', provider),
    // register a dynamic configuration provider for 'dfdl' debug type
    vscode.debug.registerDebugConfigurationProvider(
      'dfdl',
      {
        provideDebugConfigurations(
          folder: WorkspaceFolder | undefined
        ): ProviderResult<DebugConfiguration[]> {
          if (!vscode.workspace.workspaceFolders) {
            return [
              getConfig({
                name: 'Daffodil Launch',
                request: 'launch',
                type: 'dfdl',
                schema: {
                  path: '${file}',
                  rootName: null,
                  rootNamespace: null,
                },
                data: '${command:AskForDataName}',
                debugServer: false,
                infosetFormat: 'xml',
                infosetOutput: {
                  type: 'file',
                  path: '${file}-infoset.xml',
                },
              }),
            ]
          }

          let targetResource = vscode.window.activeTextEditor
            ? vscode.window.activeTextEditor.document.uri
            : vscode.workspace.workspaceFolders[0].uri
          let infosetFile = `${
            path.basename(targetResource.fsPath).split('.')[0]
          }-infoset.xml`

          return [
            getConfig({
              name: 'Daffodil Launch',
              request: 'launch',
              type: 'dfdl',
              schema: {
                path: '${file}',
                rootName: null,
                rootNamespace: null,
              },
              data: '${command:AskForDataName}',
              debugServer: false,
              infosetFormat: 'xml',
              infosetOutput: {
                type: 'file',
                path: '${workspaceFolder}/' + infosetFile,
              },
            }),
          ]
        },
      },
      vscode.DebugConfigurationProviderTriggerKind.Dynamic
    )
  )

  if (!factory) {
    factory = new InlineDebugAdapterFactory(context)
  }
  context.subscriptions.push(
    vscode.debug.registerDebugAdapterDescriptorFactory('dfdl', factory)
  )
  if ('dispose' in factory) {
    context.subscriptions.push(factory as vscode.Disposable)
  }

  context.subscriptions.push(
    // override VS Code's default implementation of the debug hover
    vscode.languages.registerEvaluatableExpressionProvider('xml', {
      provideEvaluatableExpression(
        document: vscode.TextDocument,
        position: vscode.Position
      ): vscode.ProviderResult<vscode.EvaluatableExpression> {
        const wordRange = document.getWordRangeAtPosition(position)
        return wordRange
          ? new vscode.EvaluatableExpression(wordRange)
          : undefined
      },
    }),
    // override VS Code's default implementation of the "inline values" feature"
    vscode.languages.registerInlineValuesProvider('xml', {
      provideInlineValues(
        document: vscode.TextDocument,
        viewport: vscode.Range,
        context: vscode.InlineValueContext
      ): vscode.ProviderResult<vscode.InlineValue[]> {
        const allValues: vscode.InlineValue[] = []

        for (
          let l = viewport.start.line;
          l <= context.stoppedLocation.end.line;
          l++
        ) {
          const line = document.lineAt(l)
          var regExp = /local_[ifso]/gi // match variables of the form local_i, local_f, Local_i, LOCAL_S...
          do {
            var m = regExp.exec(line.text)
            if (m) {
              const varName = m[0]
              const varRange = new vscode.Range(
                l,
                m.index,
                l,
                m.index + varName.length
              )

              // value found via variable lookup
              allValues.push(
                new vscode.InlineValueVariableLookup(varRange, varName, false)
              )
            }
          } while (m)
        }

        return allValues
      },
    })
  )

  context.subscriptions.push(
    vscode.debug.onDidReceiveDebugSessionCustomEvent(handleDebugEvent)
  )

  dfdlLang.activate(context)
  dfdlExt.activate(context)
  infoset.activate(context)
  dataEditClient.activate(context)
  launchWizard.activate(context)
  tdmlEditor.activate(context)
  rootCompletion.activate(context)

  daffodilDebugErrors.activate()
}

class DaffodilConfigurationProvider
  implements vscode.DebugConfigurationProvider
{
  context: vscode.ExtensionContext

  constructor(context: vscode.ExtensionContext) {
    this.context = context
  }
  /**
   * Massage a debug configuration just before a debug session is being launched,
   * e.g. add all missing attributes to the debug configuration.
   */
  async resolveDebugConfiguration(
    folder: WorkspaceFolder | undefined,
    config: DebugConfiguration,
    token?: CancellationToken
  ): Promise<DebugConfiguration | undefined> {
    // if launch.json is missing or empty
    if (!config.type && !config.request && !config.name) {
      config = getConfig({ name: 'Launch', request: 'launch', type: 'dfdl' })
    }

    // default schema path and data paths to ask for file prompts if they are null, undefined, or '' in launch.json config
    config = {
      ...config,
      schema: {
        ...config.schema,
        path: config.schema?.path || '${command:AskForSchemaName}',
      },
      data: config.data || '${command:AskForDataName}',
    }

    const validTunables = getTunables(this.context)
    const currentTunables = config.tunables ?? {}

    const invalidTunables = Object.keys(currentTunables).filter(
      (name) => !(name in validTunables)
    )

    const invalidValues = Object.entries(currentTunables)
      .filter(([name, value]) => {
        if (!(name in validTunables)) {
          return false
        }

        const type = validTunables[name]

        switch (type) {
          case 'boolean':
            return value !== 'true' && value !== 'false'

          case 'number':
            return isNaN(Number(value))

          case 'string':
            return typeof value !== 'string'

          default:
            return false
        }
      })
      .map(([name]) => name)

    const invalid = [...invalidTunables, ...invalidValues]

    if (invalid.length > 0) {
      const messages = [
        ...invalidTunables.map((name) => `${name} (invalid tunable)`),
        ...invalidValues.map((name) => `${name} (invalid value)`),
      ]

      const choice = await vscode.window.showWarningMessage(
        `Invalid tunables found:\n\n${messages.join('\n')}`,
        { modal: true },
        'Ignore Invalid Tunables'
      )

      if (choice !== 'Ignore Invalid Tunables') {
        return undefined
      }

      config.tunables = { ...config.tunables }

      for (const invalidTunable of invalid) {
        delete config.tunables[invalidTunable]
      }
    }

    let dataFolder = config.data

    if (
      dataFolder.includes('${workspaceFolder}') &&
      vscode.workspace.workspaceFolders &&
      dataFolder.split('.').length === 1
    ) {
      dataFolder = vscode.workspace.workspaceFolders[0].uri.fsPath
    }

    if (
      !dataFolder.includes('${command:AskForSchemaName}') &&
      !dataFolder.includes('${command:AskForDataName}') &&
      !dataFolder.includes('${workspaceFolder}') &&
      config.tdmlConfig?.action !== 'execute' &&
      vscode.workspace.workspaceFolders &&
      dataFolder !== vscode.workspace.workspaceFolders[0].uri.fsPath &&
      dataFolder.split('.').length === 1 &&
      fs.lstatSync(dataFolder).isDirectory()
    ) {
      return getDataFileFromFolder(dataFolder).then((dataFile) => {
        config.data = dataFile
        return getDebugger(this.context, config).then((_) => {
          return getCurrentConfig()
        })
      })
    }

    return getDebugger(this.context, config).then((_) => {
      return getCurrentConfig()
    })
  }
}

export const workspaceFileAccessor: FileAccessor = {
  async readFile(path: string) {
    try {
      const uri = vscode.Uri.file(path)
      const bytes = await vscode.workspace.fs.readFile(uri)
      const contents = Buffer.from(bytes).toString('utf8')
      return contents
    } catch (e) {
      try {
        const uri = vscode.Uri.parse(path)
        const bytes = await vscode.workspace.fs.readFile(uri)
        const contents = Buffer.from(bytes).toString('utf8')
        return contents
      } catch (e) {
        return `cannot read '${path}'`
      }
    }
  },
}

/**
 * Recursively adds files and folders to a JSZip instance.
 * @param dirPath The folder to add
 * @param zip The JSZip instance
 */
function addFolderToZip(dirPath: string, zip: JSZip) {
  const files = fs.readdirSync(dirPath)

  for (const file of files) {
    const filePath = path.posix.join(dirPath, file)
    const stats = fs.statSync(filePath)

    if (stats.isDirectory()) {
      // Create a subfolder in the ZIP and recurse
      const subFolder = zip.folder(file)
      if (subFolder) {
        addFolderToZip(filePath, subFolder)
      }
    } else {
      // Read file data and add to current zip/folder
      const fileData = fs.readFileSync(filePath)
      zip.file(file, fileData)
    }
  }
}