vscode.gradle

apply from: 'scripts/versions.gradle'

def vscodeFile = file("$buildDir/vscodeConfig.json")

def vscodeWindowsZipName = "VSCode-${vsCodeVersion}-Windows.zip".toString()
def vscodeLinuxZipName = "VSCode-${vsCodeVersion}-Linux.tar.gz".toString()
def vscodeLinuxArm64ZipName = "VSCode-${vsCodeVersion}-LinuxArm64.tar.gz".toString()
def vscodeMacZipName = "VSCode-${vsCodeVersion}-Mac.zip".toString()

def vscodeWindowsUrl = "https://update.code.visualstudio.com/${vsCodeVersion}/win32-x64-archive/stable".toString()

def vscodeLinuxUrl = "https://update.code.visualstudio.com/${vsCodeVersion}/linux-x64/stable".toString()

def vscodeLinuxArm64Url = "https://update.code.visualstudio.com/${vsCodeVersion}/linux-arm64/stable".toString()

def vscodeMacUrl = "https://update.code.visualstudio.com/${vsCodeVersion}/darwin-universal/stable".toString()

def cppWindowsUrl = "https://github.com/microsoft/vscode-cpptools/releases/download/v${cppToolsVersion}/cpptools-windows-x64.vsix"

def cppMacUrl = "https://github.com/microsoft/vscode-cpptools/releases/download/v${cppToolsVersion}/cpptools-macOS-x64.vsix"

def cppMacArmUrl = "https://github.com/microsoft/vscode-cpptools/releases/download/v${cppToolsVersion}/cpptools-macOS-arm64.vsix"

def cppLinuxUrl = "https://github.com/microsoft/vscode-cpptools/releases/download/v${cppToolsVersion}/cpptools-linux-x64.vsix"

def cppLinuxArm64Url = "https://github.com/microsoft/vscode-cpptools/releases/download/v${cppToolsVersion}/cpptools-linux-arm64.vsix"

def pythonWindowsUrl = "https://frcmaven.wpi.edu/api/download/vscode-extensions/ms-python/python/ms-python.python-${pythonExtVersion}@win32-x64.vsix"

def pythonMacUrl = "https://frcmaven.wpi.edu/api/download/vscode-extensions/ms-python/python/ms-python.python-${pythonExtVersion}@darwin-x64.vsix"

def pythonMacArmUrl = "https://frcmaven.wpi.edu/api/download/vscode-extensions/ms-python/python/ms-python.python-${pythonExtVersion}@darwin-arm64.vsix"

def pythonLinuxUrl = "https://frcmaven.wpi.edu/api/download/vscode-extensions/ms-python/python/ms-python.python-${pythonExtVersion}@linux-x64.vsix"

def pythonLinuxArm64Url = "https://frcmaven.wpi.edu/api/download/vscode-extensions/ms-python/python/ms-python.python-${pythonExtVersion}@linux-arm64.vsix"

def pylanceUrl = "https://frcmaven.wpi.edu/artifactory/vscode-extensions/ms-python/vscode-pylance/ms-python.vscode-pylance-${pylanceVersion}.vsix"

def isortUrl = "https://open-vsx.org/api/ms-python/isort/${isortVersion}/file/ms-python.isort-${isortVersion}.vsix"

def blackUrl = "https://open-vsx.org/api/ms-python/black-formatter/${blackVersion}/file/ms-python.black-formatter-${blackVersion}.vsix"

def wpilibExtensionUrl = "https://github.com/wpilibsuite/vscode-wpilib/releases/download/v${wpilibVersion}/vscode-wpilib-${wpilibVersion}.vsix"

def wpilibUtilWinUrl = "https://github.com/wpilibsuite/vscode-wpilib/releases/download/v${wpilibVersion}/wpilibutility-windows.zip"

def wpilibUtilLinuxUrl = "https://github.com/wpilibsuite/vscode-wpilib/releases/download/v${wpilibVersion}/wpilibutility-linux.tar.gz"

def wpilibUtilMacUrl = "https://github.com/wpilibsuite/vscode-wpilib/releases/download/v${wpilibVersion}/wpilibutility-mac.tar.gz"

def javaDebugUrl = "https://open-vsx.org/api/vscjava/vscode-java-debug/${javaDebugVersion}/file/vscjava.vscode-java-debug-${javaDebugVersion}.vsix"

def javaLangUrl = "https://github.com/redhat-developer/vscode-java/releases/download/v${javaExtVersion}/vscode-java-${javaExtVersion}-${javaExtPatchVersion}.vsix"

def javaDepUrl = "https://open-vsx.org/api/vscjava/vscode-java-dependency/${javaDependencyVersion}/file/vscjava.vscode-java-dependency-${javaDependencyVersion}.vsix"

def vscodeWindowsDownload = tasks.register("vscodeWindowsDownload", Download) {
  src vscodeWindowsUrl
  dest "$buildDir/downloads/$vscodeWindowsZipName"
  overwrite false
  retries 1
}

def verifyWindows = tasks.register("verifyVscodeWindowsDownload", Verify) {
  dependsOn vscodeWindowsDownload
  inputs.files vscodeWindowsDownload.get().outputFiles.first()
  inputs.property 'hash', vscodeWindowsHash
  src vscodeWindowsDownload.get().outputFiles.first()
  algorithm 'SHA-256'
  checksum vscodeWindowsHash
}

def vscodeMacDownload = tasks.register("vscodeMacDownload", Download) {
  src vscodeMacUrl
  dest "$buildDir/downloads/$vscodeMacZipName"
  overwrite false
  retries 1
}

def verifyMac = tasks.register("verifyVscodeMacDownload", Verify) {
  dependsOn vscodeMacDownload
  inputs.files vscodeMacDownload.get().outputFiles.first()
  inputs.property 'hash', vscodeMacHash
  src vscodeMacDownload.get().outputFiles.first()
  algorithm 'SHA-256'
  checksum vscodeMacHash
}

def vscodeLinuxDownload = tasks.register("vscodeLinuxDownload", Download) {
  src vscodeLinuxUrl
  dest "$buildDir/downloads/$vscodeLinuxZipName"
  overwrite false
  retries 1
}

def verifyLinux = tasks.register("verifyVscodeLinuxDownload", Verify) {
  dependsOn vscodeLinuxDownload
  inputs.files vscodeLinuxDownload.get().outputFiles.first()
  inputs.property 'hash', vscodeLinuxHash
  src vscodeLinuxDownload.get().outputFiles.first()
  algorithm 'SHA-256'
  checksum vscodeLinuxHash
}

def vscodeLinuxArm64Download = tasks.register("vscodeLinuxArm64Download", Download) {
  src vscodeLinuxArm64Url
  dest "$buildDir/downloads/$vscodeLinuxArm64ZipName"
  overwrite false
  retries 1
}

def verifyLinuxArm64 = tasks.register("verifyVscodeLinuxArm64Download", Verify) {
  dependsOn vscodeLinuxArm64Download
  inputs.files vscodeLinuxArm64Download.get().outputFiles.first()
  inputs.property 'hash', vscodeLinuxArm64Hash
  src vscodeLinuxArm64Download.get().outputFiles.first()
  algorithm 'SHA-256'
  checksum vscodeLinuxArm64Hash
}

def wpilibExtensionDownload = tasks.register("wpilibExtensionDownload", Download) {
  src wpilibExtensionUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def standaloneDownload = tasks.register("standaloneDownload", Download) {

  if (project.hasProperty('linuxBuild')) {
    src wpilibUtilLinuxUrl
  } else if (project.hasProperty('macBuild') || project.hasProperty('macBuildArm')) {
    src wpilibUtilMacUrl
  } else {
    src wpilibUtilWinUrl
  }
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def cppExtensionDownload = tasks.register("cppExtensionDownload", Download) {
  src cppWindowsUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def cppMacExtensionDownload = tasks.register("cppMacExtensionDownload", Download) {
  src cppMacUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def cppMacArmExtensionDownload = tasks.register("cppMacArmExtensionDownload", Download) {
  src cppMacArmUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}


def cppLinuxExtensionDownload = tasks.register("cppLinuxExtensionDownload", Download) {
  src cppLinuxUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def cppLinuxArm64ExtensionDownload = tasks.register("cppLinuxArm64ExtensionDownload", Download) {
  src cppLinuxArm64Url
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}


def javaLangExtensionDownload = tasks.register("javaLangExtensionDownload", Download) {
  src javaLangUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}


def javaDebugExtensionDownload = tasks.register("javaDebugExtensionDownload", Download) {
  src javaDebugUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def javaDepExtensionDownload = tasks.register("javaDepExtensionDownload", Download) {
  src javaDepUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}


def pythonExtensionDownload = tasks.register("pythonExtensionDownload", Download) {
  src pythonWindowsUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def pythonMacExtensionDownload = tasks.register("pythonMacExtensionDownload", Download) {
  src pythonMacUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def pythonMacArmExtensionDownload = tasks.register("pythonMacArmExtensionDownload", Download) {
  src pythonMacArmUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def pythonLinuxExtensionDownload = tasks.register("pythonLinuxExtensionDownload", Download) {
  src pythonLinuxUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def pythonLinuxArm64ExtensionDownload = tasks.register("pythonLinuxArm64ExtensionDownload", Download) {
  src pythonLinuxArm64Url
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}



def pylanceExtensionDownload = tasks.register("pylanceExtensionDownload", Download) {
  src pylanceUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}


def isortExtensionDownload = tasks.register("isortExtensionDownload", Download) {
  src isortUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}


def blackExtensionDownload = tasks.register("blackExtensionDownload", Download) {
  src blackUrl
  def fileName = file(src.file).name
  dest "$buildDir/downloads/$fileName"
  overwrite false
}

def cppDownloadTask
if (project.hasProperty('linuxBuild')) {
  cppDownloadTask = cppLinuxExtensionDownload
} else if (project.hasProperty('linuxBuildArm64')) {
  cppDownloadTask = cppLinuxArm64ExtensionDownload
} else if (project.hasProperty('macBuild')) {
  cppDownloadTask = cppMacExtensionDownload
} else if (project.hasProperty('macBuildArm')) {
  cppDownloadTask = cppMacArmExtensionDownload
} else {
  cppDownloadTask = cppExtensionDownload
}

def pythonDownloadTask
if (project.hasProperty('linuxBuild')) {
  pythonDownloadTask = pythonLinuxExtensionDownload
} else if (project.hasProperty('linuxBuildArm64')) {
  pythonDownloadTask = pythonLinuxArm64ExtensionDownload
} else if (project.hasProperty('macBuild')) {
  pythonDownloadTask = pythonMacExtensionDownload
} else if (project.hasProperty('macBuildArm')) {
  pythonDownloadTask = pythonMacArmExtensionDownload
} else {
  pythonDownloadTask = pythonExtensionDownload
}

def getInformationOfVsix = { vsix, map->
  def pkg = vsix.matching { include '**/extension/package.json' }.files.asList()[0]
  def packageJson = new groovy.json.JsonSlurper().parseText(pkg.text)
  map['name'] = "${packageJson.publisher}.${packageJson.name}".toString()
  map['version'] = packageJson.version
}

def vscodeTask = tasks.register('vscodeConfig', Task) {
  dependsOn wpilibExtensionDownload
  dependsOn cppDownloadTask
  dependsOn javaLangExtensionDownload
  dependsOn javaDebugExtensionDownload
  dependsOn javaDepExtensionDownload
  dependsOn pythonDownloadTask
  dependsOn pylanceExtensionDownload
  dependsOn isortExtensionDownload
  dependsOn blackExtensionDownload
  dependsOn verifyVscodeLinuxDownload
  dependsOn verifyVscodeLinuxArm64Download
  dependsOn verifyVscodeWindowsDownload
  dependsOn verifyVscodeMacDownload

  inputs.files wpilibExtensionDownload.get().outputFiles
  inputs.files cppDownloadTask.get().outputFiles
  inputs.files javaLangExtensionDownload.get().outputFiles
  inputs.files javaDebugExtensionDownload.get().outputFiles
  inputs.files javaDepExtensionDownload.get().outputFiles
  inputs.files pythonDownloadTask.get().outputFiles
  inputs.files pylanceExtensionDownload.get().outputFiles
  inputs.files isortExtensionDownload.get().outputFiles
  inputs.files blackExtensionDownload.get().outputFiles

  inputs.property 'linuxhash', vscodeLinuxHash
  inputs.property 'linuxarm64hash', vscodeLinuxArm64Hash
  inputs.property 'machash', vscodeMacHash
  inputs.property 'winhash', vscodeWindowsHash

  doLast {
    def config = [:]

    def wpilibMap = [:]
    wpilibMap['vsix'] = wpilibExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(wpilibExtensionDownload.get().outputFiles.first()), wpilibMap)
    def cppMap = [:]
    cppMap['vsix'] = cppDownloadTask.get().outputFiles.first().name
    getInformationOfVsix(zipTree(cppDownloadTask.get().outputFiles.first()), cppMap)
    def javaLangMap = [:]
    javaLangMap['vsix'] = javaLangExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(javaLangExtensionDownload.get().outputFiles.first()), javaLangMap)
    def javaDebugMap = [:]
    javaDebugMap['vsix'] = javaDebugExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(javaDebugExtensionDownload.get().outputFiles.first()), javaDebugMap)
    def javaDepMap = [:]
    javaDepMap['vsix'] = javaDepExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(javaDepExtensionDownload.get().outputFiles.first()), javaDepMap)
    def pythonMap = [:]
    pythonMap['vsix'] = pythonDownloadTask.get().outputFiles.first().name
    getInformationOfVsix(zipTree(pythonDownloadTask.get().outputFiles.first()), pythonMap)
    def pylanceMap = [:]
    pylanceMap['vsix'] = pylanceExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(pylanceExtensionDownload.get().outputFiles.first()), pylanceMap)
    def isortMap = [:]
    isortMap['vsix'] = isortExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(isortExtensionDownload.get().outputFiles.first()), isortMap)
    def blackMap = [:]
    blackMap['vsix'] = blackExtensionDownload.get().outputFiles.first().name
    getInformationOfVsix(zipTree(blackExtensionDownload.get().outputFiles.first()), blackMap)

    config['VsCodeWindowsUrl'] = vscodeWindowsUrl
    config['VsCodeWindowsName'] = vscodeWindowsZipName
    config['VsCodeWindowsHash'] = vscodeWindowsHash
    config['VsCodeMacUrl'] = vscodeMacUrl
    config['VsCodeMacName'] = vscodeMacZipName
    config['VsCodeMacHash'] = vscodeMacHash
    config['VsCodeLinuxUrl'] = vscodeLinuxUrl
    config['VsCodeLinuxName'] = vscodeLinuxZipName
    config['VsCodeLinuxHash'] = vscodeLinuxHash

    config['VsCodeLinuxArm64Url'] = vscodeLinuxArm64Url
    config['VsCodeLinuxArm64Name'] = vscodeLinuxArm64ZipName
    config['VsCodeLinuxArm64Hash'] = vscodeLinuxArm64Hash

    config['VsCodeVersion'] = vsCodeVersion

    config['wpilibExtension'] = wpilibMap

    config['thirdPartyExtensions'] = [
      cppMap,
      javaLangMap,
      javaDebugMap,
      javaDepMap,
      pythonMap,
      pylanceMap,
      isortMap,
      blackMap
    ]


    def gbuilder = getGsonBuilder()

    gbuilder.setPrettyPrinting()
    def json = gbuilder.create().toJson(config)

    vscodeFile.parentFile.mkdirs()

    vscodeFile.text = json
  }
}

ext.vscodeConfigZipSetup = { AbstractArchiveTask zip->
  zip.dependsOn vscodeTask
  zip.inputs.file vscodeFile

  zip.from (vscodeFile)
}

ext.vscodeZipSetup = { AbstractArchiveTask zip->
  zip.dependsOn vscodeTask
  zip.dependsOn wpilibExtensionDownload
  zip.dependsOn standaloneDownload

  zip.inputs.file vscodeFile

  if (project.hasProperty('linuxBuild')) {
    // Linux
    zip.from(project.tarTree(project.resources.gzip(standaloneDownload.get().outputFiles.first()))) {
      into '/utility'
      includeEmptyDirs = false
    }
  } else if (project.hasProperty('macBuild') || project.hasProperty('macBuildArm')) {
    // Mac
    // Cannot extract, otherwise mac borks
    zip.from (standaloneDownload.get().outputFiles.first()) {
      into '/utility'
    }
  } else if (project.hasProperty('linuxBuildArm64')) {
  } else {
    // Windows
    zip.from(project.zipTree(standaloneDownload.get().outputFiles.first())) {
      into '/utility'

      includeEmptyDirs = false
    }
  }

  zip.from (vscodeFile) {
    into '/installUtils'
  }

  zip.from (javaLangExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (javaDebugExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (cppDownloadTask.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (wpilibExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (javaDepExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (pythonDownloadTask.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (pylanceExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (isortExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
  zip.from (blackExtensionDownload.get().outputFiles.first()) {
    into '/vsCodeExtensions'
  }
}