import com.coder.gateway.cli.CoderCLIManager

import com.coder.gateway.cli.ensureCLI

import com.coder.gateway.models.AGENT_ID

import com.coder.gateway.models.AGENT_NAME

import com.coder.gateway.models.TOKEN

import com.coder.gateway.models.URL

import com.coder.gateway.models.WORKSPACE

import com.coder.gateway.models.WorkspaceAndAgentStatus

import com.coder.gateway.models.WorkspaceProjectIDE

import com.coder.gateway.models.agentID

import com.coder.gateway.models.agentName

import com.coder.gateway.models.folder

import com.coder.gateway.models.ideBuildNumber

import com.coder.gateway.models.ideDownloadLink

import com.coder.gateway.models.idePathOnHost

import com.coder.gateway.models.ideProductCode

import com.coder.gateway.models.isCoder

import com.coder.gateway.models.token

import com.coder.gateway.models.url

import com.coder.gateway.models.workspace

import com.coder.gateway.sdk.CoderRestClient

import com.coder.gateway.sdk.ex.APIResponseException

import com.coder.gateway.sdk.v2.models.Workspace

import com.coder.gateway.sdk.v2.models.WorkspaceAgent

import com.coder.gateway.sdk.v2.models.WorkspaceStatus

import com.coder.gateway.services.CoderRestClientService

import com.coder.gateway.settings.Source

import com.coder.gateway.util.toURL

import com.coder.gateway.views.steps.CoderWorkspaceProjectIDEStepView

import com.coder.gateway.views.steps.CoderWorkspacesStepSelection

import com.intellij.openapi.application.ApplicationManager

import com.intellij.openapi.ui.DialogWrapper

import com.intellij.ui.dsl.builder.panel

import com.intellij.util.ui.JBUI

import javax.swing.JComponent

import javax.swing.border.Border

class CoderWorkspaceStepDialog(

name: String,

private val state: CoderWorkspacesStepSelection,

) : DialogWrapper(true) {

private val view = CoderWorkspaceProjectIDEStepView(showTitle = false)

init {

init()

title = CoderGatewayBundle.message("gateway.connector.view.coder.remoteproject.choose.text", name)

}

override fun show() {

view.init(state)

view.onPrevious = { close(1) }

view.onNext = { close(0) }

super.show()

view.dispose()

}

fun showAndGetData(): WorkspaceProjectIDE? {

if (showAndGet()) {

return view.data()

}

return null

}

override fun createContentPaneBorder(): Border {

return JBUI.Borders.empty()

}

override fun createCenterPanel(): JComponent {

return view

}

override fun createSouthPanel(): JComponent {

// The plugin provides its own buttons.

// TODO: Is it more idiomatic to handle buttons out here?

return panel {}.apply {

border = JBUI.Borders.empty()

}

}

}

logger.debug("Launched Coder connection provider", parameters)

val deploymentURL =

parameters.url()

?: CoderRemoteConnectionHandle.ask("Enter the full URL of your Coder deployment")

if (deploymentURL.isNullOrBlank()) {

throw IllegalArgumentException("Query parameter \"$URL\" is missing")

}

val client = authenticate(deploymentURL, parameters.token())

// TODO: If the workspace is missing we could launch the wizard.

val workspaceName = parameters.workspace() ?: throw IllegalArgumentException("Query parameter \"$WORKSPACE\" is missing")

val workspaces = client.workspaces()

val workspace =

workspaces.firstOrNull {

it.name == workspaceName

} ?: throw IllegalArgumentException("The workspace $workspaceName does not exist")

when (workspace.latestBuild.status) {

WorkspaceStatus.PENDING, WorkspaceStatus.STARTING ->

// TODO: Wait for the workspace to turn on.

throw IllegalArgumentException(

"The workspace \"$workspaceName\" is ${workspace.latestBuild.status.toString().lowercase()}; please wait then try again",

)

WorkspaceStatus.STOPPING, WorkspaceStatus.STOPPED,

WorkspaceStatus.CANCELING, WorkspaceStatus.CANCELED,

->

// TODO: Turn on the workspace.

throw IllegalArgumentException(

"The workspace \"$workspaceName\" is ${workspace.latestBuild.status.toString().lowercase()}; please start the workspace and try again",

)

WorkspaceStatus.FAILED, WorkspaceStatus.DELETING, WorkspaceStatus.DELETED ->

throw IllegalArgumentException(

"The workspace \"$workspaceName\" is ${workspace.latestBuild.status.toString().lowercase()}; unable to connect",

)

WorkspaceStatus.RUNNING -> Unit // All is well

}

// TODO: Show a dropdown and ask for an agent if missing.

val agent = getMatchingAgent(parameters, workspace)

val status = WorkspaceAndAgentStatus.from(workspace, agent)

if (status.pending()) {

// TODO: Wait for the agent to be ready.

throw IllegalArgumentException(

"The agent \"${agent.name}\" is ${status.toString().lowercase()}; please wait then try again",

)

} else if (!status.ready()) {

throw IllegalArgumentException("The agent \"${agent.name}\" is ${status.toString().lowercase()}; unable to connect")

}

val cli =

ensureCLI(

deploymentURL.toURL(),

client.buildInfo().version,

settings,

indicator,

)

// We only need to log in if we are using token-based auth.

if (client.token !== null) {

indicator.text = "Authenticating Coder CLI..."

cli.login(client.token)

}

indicator.text = "Configuring Coder CLI..."

cli.configSsh(client.agentNames(workspaces))

val name = "${workspace.name}.${agent.name}"

val openDialog =

parameters.ideProductCode().isNullOrBlank() ||

parameters.ideBuildNumber().isNullOrBlank() ||

(parameters.idePathOnHost().isNullOrBlank() && parameters.ideDownloadLink().isNullOrBlank()) ||

parameters.folder().isNullOrBlank()

if (openDialog) {

var data: WorkspaceProjectIDE? = null

ApplicationManager.getApplication().invokeAndWait {

val dialog =

CoderWorkspaceStepDialog(

name,

CoderWorkspacesStepSelection(agent, workspace, cli, client, workspaces),

)

data = dialog.showAndGetData()

}

data ?: throw Exception("IDE selection aborted; unable to connect")

} else {

// Check that both the domain and the redirected domain are

// allowlisted. If not, check with the user whether to proceed.

verifyDownloadLink(parameters)

WorkspaceProjectIDE.fromInputs(

name = name,

hostname = CoderCLIManager.getHostName(deploymentURL.toURL(), name),

projectPath = parameters.folder(),

ideProductCode = parameters.ideProductCode(),

ideBuildNumber = parameters.ideBuildNumber(),

idePathOnHost = parameters.idePathOnHost(),

downloadSource = parameters.ideDownloadLink(),

deploymentURL = deploymentURL,

lastOpened = null, // Have not opened yet.

)

/**

private fun authenticate(

deploymentURL: String,

queryToken: String?,

lastToken: Pair<String, Source>? = null,

): CoderRestClient {

val token =

if (settings.requireTokenAuth) {

// Use the token from the query, unless we already tried that.

val isRetry = lastToken != null

if (!queryToken.isNullOrBlank() && !isRetry) {

Pair(queryToken, Source.QUERY)

} else {

CoderRemoteConnectionHandle.askToken(

deploymentURL.toURL(),

lastToken,

isRetry,

useExisting = true,

settings,

)

}

} else {

null

}

if (settings.requireTokenAuth && token == null) { // User aborted.

throw IllegalArgumentException("Unable to connect to $deploymentURL, query parameter \"$TOKEN\" is missing")

}

val client = CoderRestClientService(deploymentURL.toURL(), token?.first)

return try {

client.authenticate()

client

} catch (ex: APIResponseException) {

// If doing token auth we can ask and try again.

if (settings.requireTokenAuth && ex.isUnauthorized) {

authenticate(deploymentURL, queryToken, token)

} else {

throw ex

}

}

}

/**

private fun verifyDownloadLink(parameters: Map<String, String>) {

val link = parameters.ideDownloadLink()

if (link.isNullOrBlank()) {

return // Nothing to verify

}

val url =

try {

link.toURL()

} catch (ex: Exception) {

throw IllegalArgumentException("$link is not a valid URL")

}

val (allowlisted, https, linkWithRedirect) =

try {

CoderRemoteConnectionHandle.isAllowlisted(url)

} catch (e: Exception) {

throw IllegalArgumentException("Unable to verify $url: $e")

}

if (allowlisted && https) {

return

}

val comment =

if (allowlisted) {

"The download link is from a non-allowlisted URL"

} else if (https) {

"The download link is not using HTTPS"

} else {

"The download link is from a non-allowlisted URL and is not using HTTPS"

}

if (!CoderRemoteConnectionHandle.confirm(

"Confirm download URL",

"$comment. Would you like to proceed?",

linkWithRedirect,

)

) {

throw IllegalArgumentException("$linkWithRedirect is not allowlisted")

}

}

fun getMatchingAgent(

parameters: Map<String, String?>,

workspace: Workspace,

): WorkspaceAgent {

val agents = workspace.latestBuild.resources.filter { it.agents != null }.flatMap { it.agents!! }

if (agents.isEmpty()) {

throw IllegalArgumentException("The workspace \"${workspace.name}\" has no agents")

}

// If the agent is missing and the workspace has only one, use that.

// Prefer the ID over the name if both are set.

val agent =

if (!parameters.agentID().isNullOrBlank()) {

agents.firstOrNull { it.id.toString() == parameters.agentID() }

} else if (!parameters.agentName().isNullOrBlank()) {

agents.firstOrNull { it.name == parameters.agentName() }

} else if (agents.size == 1) {

agents.first()

} else {

null

}

if (agent == null) {

if (!parameters.agentID().isNullOrBlank()) {

throw IllegalArgumentException("The workspace \"${workspace.name}\" does not have an agent with ID \"${parameters.agentID()}\"")

} else if (!parameters.agentName().isNullOrBlank()) {

throw IllegalArgumentException(

"The workspace \"${workspace.name}\"does not have an agent named \"${parameters.agentName()}\"",

)

} else {

throw MissingArgumentException(

"Unable to determine which agent to connect to; one of \"$AGENT_NAME\" or \"$AGENT_ID\" must be set because the workspace \"${workspace.name}\" has more than one agent",

)

}

}

return agent

}

class MissingArgumentException(message: String) : IllegalArgumentException(message)