export async function selectTransport(
  objContentPath: string,
  devClass: string,
  client: ADTClient,
  forCreation: boolean = false
): Promise<TransportSelection> {
  const ti = await client.transportInfo(
    objContentPath,
    devClass,
    forCreation ? "I" : ""
  )
  // if I have a lock return the locking transport
  // will probably be a task but should be fine

  if (ti.LOCKS) return sel(ti.LOCKS.HEADER.TRKORR)

  if (ti.DLVUNIT === "LOCAL") return sel("")
  const CREATENEW = "Create a new transport"
  const selection = await window.showQuickPick([
    CREATENEW,
    ...ti.TRANSPORTS.map(t => `${t.TRKORR} ${t.AS4TEXT}`)
  ])

  if (!selection) return sel("", true)
  if (selection === CREATENEW) {
    const text = await window.showInputBox({ prompt: "Request text" })
    if (!text) return sel("", true)
    return sel(await client.createTransport(objContentPath, text, ti.DEVCLASS))
  } else return sel(selection.split(" ")[0])
}

 public getContentsUri(): string {
   if (!this.structure || !this.techName)
     throw FileSystemError.FileNotFound(this.path)
   const include = ADTClient.classIncludes(this.structure).get(this
     .techName as classIncludes)
   if (!include) throw FileSystemError.FileNotFound(this.path)
   return include
 }

 public async loadMetadata(client: ADTClient): Promise<AbapObject> {
   if (this.name) {
     const struc = await client.objectStructure(this.path)
     if (isClassStructure(struc)) {
       this.structure = struc
     }
   }
   return this
 }

  public async getChildren(
    client: ADTClient
  ): Promise<AbapNodeComponentByCategory[]> {
    if (this.isLeaf()) throw FileSystemError.FileNotADirectory(this.vsName)
    if (!this.structure) await this.loadMetadata(client)
    if (!this.structure) throw FileSystemError.FileNotFound(this.vsName)

    const ns: NodeStructureMapped = {
      categories: new Map(),
      objectTypes: new Map(),
      nodes: []
    }
    const main = this.selfLeafNode()
    main.OBJECT_URI = ADTClient.mainInclude(this.structure)
    const sources = ADTClient.classIncludes(this.structure)
    this.structure.includes.forEach(i => {
      const node = {
        EXPANDABLE: "",
        OBJECT_NAME: this.name + "." + i["class:includeType"],
        OBJECT_TYPE: i["adtcore:type"],
        OBJECT_URI: sources.get(i["class:includeType"] as classIncludes) || "",
        OBJECT_VIT_URI: "",
        TECH_NAME: i["class:includeType"] // bit of a hack, used to match include metadata
      }
      if (node.OBJECT_URI) {
        if (i["abapsource:sourceUri"] === "source/main") ns.nodes.unshift(node)
        else ns.nodes.push(node)
      }
    })

    const aggregated = aggregateNodes(ns, this.type)
    for (const cat of aggregated)
      for (const type of cat.types)
        for (const incl of type.objects)
          if (isClassInclude(incl)) incl.setParent(this)

    return aggregated
  }

 public async activate(object: AbapObject) {
   // TODO: handle multiple inactive components
   const inactive = object.getActivationSubject()
   let result
   let message
   try {
     result = await this.client.activate(inactive.name, inactive.path)
     if (result.inactive.length > 0) {
       const inactives = inactiveObjectsInResults(result)
       result = await this.client.activate(inactives)
     }
   } catch (e) {
     if (isAdtError(e) && e.type === "invalidMainProgram") {
       const mainProg = await this.selectMain(inactive)
       if (mainProg)
         result = await this.client.activate(
           inactive.name,
           inactive.path,
           mainProg
         )
     } else message = e.toString()
   }
   if (result && result.success) {
     await inactive.loadMetadata(this.client)
   } else {
     window.showErrorMessage(
       (result && result.messages[0] && result.messages[0].shortText) ||
         message ||
         `Error activating ${object.name}`
     )
   }
 }