import {
  Component,
  EventEmitter,
  Input,
  OnInit,
  Output,
  ViewEncapsulation
} from '@angular/core'
import SASjs, { SASjsConfig } from '@sasjs/adapter'
import { DcAdapterSettings } from 'src/app/models/DcAdapterSettings'
import { HelperService } from 'src/app/services'
import { DeployService } from 'src/app/services/deploy.service'
import { EventService } from 'src/app/services/event.service'
import { LoggerService } from 'src/app/services/logger.service'
import { SasViyaService } from 'src/app/services/sas-viya.service'
import { SasService } from 'src/app/services/sas.service'
import { ViyaApiCurrentUser } from 'src/app/viya-api-explorer/models/viya-api-current-user.model'
import {
  Item,
  ViyaApiIdentities
} from 'src/app/viya-api-explorer/models/viya-api-identities.model'
import { ComputeContextDetails } from 'src/app/viya-api-explorer/models/viya-compute-context-details.model'
import {
  ViyaComputeContexts,
  Item as ComputeContextItem
} from 'src/app/viya-api-explorer/models/viya-compute-contexts.model'

export interface ComputeContextInfo {
  id: string
  name: string
  runAs: string | null
  reusable: boolean
}

@Component({
  selector: 'app-automatic-deploy',
  templateUrl: './automatic.component.html',
  styleUrls: ['./automatic.component.scss'],
  encapsulation: ViewEncapsulation.None,
  standalone: false
})
export class AutomaticComponent implements OnInit {
  @Input() sasJs!: SASjs
  @Input() sasJsConfig: SASjsConfig = new SASjsConfig()
  @Input() dcAdapterSettings: DcAdapterSettings | undefined
  @Input() appLoc: string = ''
  @Input() dcPath: string = ''
  @Input() selectedAdminGroup: string = ''

  @Output() onNavigateToHome: EventEmitter<any> = new EventEmitter<any>()

  public selectedComputeContext: string = ''
  public makeDataResponse: string = ''
  public jsonFile: any = null
  public autodeploying: boolean = false
  public autodeployDone: boolean = false
  public recreateDatabaseModal: boolean = false
  public isSubmittingJson: boolean = false
  public isJsonSubmitted: boolean = false
  /**
   * Default was `false` when deploy was done with frontend and backend separately.
   * Now we are using only streaming app, so we always want to recreate database (makedata)
   */
  public recreateDatabase: boolean = true
  public createDatabaseLoading: boolean = false
  public adminGroupsLoading: boolean = false
  public currentUserInfoLoading: boolean = false
  public computeContextsLoading: boolean = false
  public adminGroups: { id: string; name: string }[] = []
  /** Compute contexts enriched with their batch identity and reusability */
  public computeContextInfos: ComputeContextInfo[] = []
  /** Distinct batch identities (runServerAs) across reusable contexts */
  public batchIds: string[] = []
  public selectedBatchId: string = ''
  /**
   * When enabled, any compute context can be chosen (the batch id dropdown
   * is hidden and no reusability / batch id filtering is applied)
   */
  public showAllContexts: boolean = false
  /** All groups on the Viya server */
  public allAdminGroups: { id: string; name: string }[] = []
  /** Groups the current user is a member of */
  public memberAdminGroups: { id: string; name: string }[] = []
  public showAllGroups: boolean = false
  public runningAsUser: string | undefined
  public currentUserInfo: ViyaApiCurrentUser | null = null
  public computeContexts: ComputeContextItem[] = []

  /** autoDeployStatus
   * This object presents the status for two steps that we have for deploy.
   * `deployServicePack` - Creating services based on `viya.json`
   * `runMakeData` - Running `makedata` service
   * If any of them is `null` or `false` that means step failed
   * and will be shown to user on deploy done modal.
   */
  public autoDeployStatus: {
    deployServicePack: any
    runMakeData: any
  } = {
    deployServicePack: null,
    runMakeData: null
  }

  public sasjsConfig = this.sasService.getSasjsConfig()

  /**
   * makedata service will be run in a new window
   * This is needed to ensure that the user can see the logs
   * and the progress of the service execution.
   * If this is set to `false`, the service will be run in the same window
   * using the adapter request method.
   */
  public deployInNewWindow: boolean = true

  constructor(
    private eventService: EventService,
    private deployService: DeployService,
    private sasService: SasService,
    private sasViyaService: SasViyaService,
    private loggerService: LoggerService,
    private helperService: HelperService
  ) {}

  ngOnInit(): void {
    this.loadData()
  }

  public async loadData() {
    await this.getCurrentUser()
    await this.getAdminGroups()
    await this.getComputeContexts()

    setTimeout(() => {
      if (this.selectedComputeContext) {
        this.onComputeContextChange(this.selectedComputeContext)
      }
    }, 500)
  }

  public async getComputeContexts() {
    return new Promise<void>((resolve, reject) => {
      this.computeContextsLoading = true

      this.sasViyaService.getComputeContexts().subscribe(
        async (res: ViyaComputeContexts) => {
          this.computeContexts = res.items

          await this.getComputeContextDetails()

          this.computeContextsLoading = false

          resolve()
        },
        (err) => {
          reject(err)
        }
      )
    })
  }

  /**
   * The `/compute/contexts` list view is minimal, so each context is fetched
   * in full (in parallel) to pick up its batch identity (runServerAs) and
   * whether it reuses server processes.  Only reusable contexts with a batch
   * identity feed the batch id dropdown.
   */
  public async getComputeContextDetails() {
    const infos = await Promise.all(
      this.computeContexts.map(
        (context: ComputeContextItem) =>
          new Promise<ComputeContextInfo>((resolveInfo) => {
            this.sasViyaService.getComputeContextById(context.id).subscribe(
              (details: ComputeContextDetails) => {
                resolveInfo({
                  id: context.id,
                  name: context.name,
                  runAs: this.extractRunAs(details),
                  reusable: details.attributes?.reuseServerProcesses === 'true'
                })
              },
              (err: any) => {
                this.loggerService.error(
                  `Error while getting compute context ${context.name}`,
                  err
                )

                resolveInfo({
                  id: context.id,
                  name: context.name,
                  runAs: null,
                  reusable: false
                })
              }
            )
          })
      )
    )

    this.computeContextInfos = infos

    this.batchIds = [
      ...new Set(
        infos
          .filter((info) => info.reusable && info.runAs)
          .map((info) => info.runAs as string)
      )
    ]

    if (this.batchIds.length) {
      this.selectedBatchId = this.batchIds[0]
    }

    const filteredContexts = this.getFilteredComputeContexts()

    const defaultContext =
      filteredContexts.find(
        (info: ComputeContextInfo) =>
          info.name === 'SAS Job Execution compute context'
      ) || filteredContexts[0]

    if (defaultContext) {
      this.selectedComputeContext = defaultContext.id
    }
  }

  /**
   * Pulls the runAs (batch) identity out of a compute context. The batch user
   * is exposed as `attributes.runServerAs` in the Viya compute context API
   * response. Not all contexts expose one.
   */
  public extractRunAs(details: ComputeContextDetails): string | null {
    return details.attributes?.runServerAs || null
  }

  /**
   * The contexts offered in the dropdown.  By default only reusable contexts
   * (`reuseServerProcesses`) matching the selected batch id are shown.  When
   * the `showAllContexts` toggle is on, all contexts are shown.
   */
  public getFilteredComputeContexts(): ComputeContextInfo[] {
    if (this.showAllContexts) {
      return this.computeContextInfos
    }

    return this.computeContextInfos.filter(
      (info: ComputeContextInfo) =>
        info.reusable && info.runAs === this.selectedBatchId
    )
  }

  /**
   * Changing the batch id re-filters the compute context dropdown and makes
   * sure the currently selected context exists in the displayed list.
   */
  public onBatchIdChange() {
    this.ensureSelectedComputeContext()
  }

  /**
   * Toggles the compute context dropdown between contexts matching the
   * selected batch id and all contexts on the Viya server.
   */
  public onShowAllContextsChange() {
    this.ensureSelectedComputeContext()
  }

  private ensureSelectedComputeContext() {
    const filteredContexts = this.getFilteredComputeContexts()

    const selectedContextExists = filteredContexts.some(
      (info: ComputeContextInfo) => info.id === this.selectedComputeContext
    )

    if (!selectedContextExists) {
      this.selectedComputeContext = filteredContexts.length
        ? filteredContexts[0].id
        : ''
    }

    this.updateRunningAsUser()
  }

  private updateRunningAsUser() {
    const selectedContext = this.computeContextInfos.find(
      (info: ComputeContextInfo) => info.id === this.selectedComputeContext
    )

    this.runningAsUser =
      selectedContext?.runAs || this.currentUserInfo?.id || 'unknown'
  }

  public async getCurrentUser() {
    return new Promise<void>((resolve, reject) => {
      this.currentUserInfoLoading = true

      this.sasViyaService.getCurrentUser().subscribe(
        (res: ViyaApiCurrentUser) => {
          this.currentUserInfoLoading = false

          this.currentUserInfo = res

          this.dcPath = `/export/viya/homes/${res.id}`

          resolve()
        },
        (err) => {
          console.error('Error while getting current user', err)
          reject(err)
        }
      )
    })
  }

  public async getAdminGroups() {
    return new Promise<void>((resolve, reject) => {
      this.adminGroupsLoading = true
      ;(this.sasViyaService
        .getAdminGroups()
        .subscribe(async (res: ViyaApiIdentities) => {
          // Map admin groups with only needed fields
          this.allAdminGroups = res.items.map((item: Item) => {
            return {
              id: item.id,
              name: item.name
            }
          })

          await this.getMemberAdminGroups()

          this.applyAdminGroupFilter()

          this.adminGroupsLoading = false

          resolve()
        }),
        (err: any) => {
          this.adminGroupsLoading = false
          this.loggerService.error('Error while getting admin groups', err)
          this.eventService.showAbortModal('admin groups', err)

          reject(err)
        })
    })
  }

  /**
   * Fetches the groups the current user is a member of, from the Viya
   * identities API.  If the memberships cannot be fetched, the member list
   * falls back to all groups.
   */
  public async getMemberAdminGroups() {
    return new Promise<void>((resolve) => {
      this.sasViyaService.getCurrentUserGroupMemberships().subscribe(
        (res: ViyaApiIdentities) => {
          const memberIds = res.items.map((item: Item) => item.id)

          this.memberAdminGroups = this.allAdminGroups.filter(
            (group: { id: string; name: string }) =>
              memberIds.includes(group.id)
          )

          resolve()
        },
        (err: any) => {
          this.loggerService.error(
            'Error while getting user group memberships',
            err
          )
          this.memberAdminGroups = this.allAdminGroups

          resolve()
        }
      )
    })
  }

  /**
   * Toggles the SAS Admin group dropdown between the groups the current user
   * is a member of and all groups on the Viya server.
   */
  public onShowAllGroupsChange() {
    this.applyAdminGroupFilter()
  }

  /**
   * Applies the member/all groups filter to the dropdown and makes sure the
   * currently selected group exists in the displayed list.
   */
  private applyAdminGroupFilter() {
    this.adminGroups =
      this.showAllGroups || !this.memberAdminGroups.length
        ? this.allAdminGroups
        : this.memberAdminGroups

    const selectedGroupExists = this.adminGroups.some(
      (group: { id: string; name: string }) =>
        group.id === this.selectedAdminGroup
    )

    if (!selectedGroupExists && this.adminGroups.length) {
      this.selectedAdminGroup = this.adminGroups[0].id
    }
  }

  public async onComputeContextChange(computeContextId: string) {
    // The explicit (ngModelChange) handler runs before the [(ngModel)]
    // assignment updates the field, so synchronise the selected context id
    // here before deriving the running user. Otherwise the displayed user
    // lags behind the dropdown by one change.
    this.selectedComputeContext = computeContextId
    this.updateRunningAsUser()
  }

  public getComputeContextName(id: string): string | undefined {
    return (
      this.computeContexts.find(
        (context: ComputeContextItem) => context.id === id
      )?.name || undefined
    )
  }

  /**
   * Executes sas.json file to deploy the backend
   * Method will first try to run the `auto deploy`
   * If that fails the rest of the code is ignored.
   * If request is successfull, method will continue to try
   * to create database if checkbox is toggled on
   */
  public async executeJson() {
    this.isSubmittingJson = true

    try {
      let uploadJsonFile = await this.sasJs.deployServicePack(
        this.jsonFile,
        this.dcAdapterSettings?.appLoc,
        undefined,
        undefined,
        true
      )

      this.autoDeployStatus.deployServicePack = true
      this.isJsonSubmitted = true
    } catch (ex: any) {
      let textEx = ''

      if (typeof ex.message !== 'string') {
        textEx = JSON.stringify(ex).replace(/\\/gm, '')
      } else {
        textEx = ex.message
      }

      this.autoDeployStatus.deployServicePack = false
      this.eventService.showInfoModal(
        'Deploy error',
        `Exception: \n ${textEx !== '' ? textEx : ex}`
      )
      this.autodeploying = false
      this.autodeployDone = false

      return
    }

    this.isSubmittingJson = false
  }

  public async runAutoDeploy(executeJson: boolean = false) {
    if (!this.deployInNewWindow) this.autodeploying = true

    if (executeJson) {
      this.executeJson()
    }

    if (this.recreateDatabase) {
      this.createDatabase()
    } else {
      if (!this.deployInNewWindow) this.autodeployDone = true
    }
  }

  /**
   * Runs the `makedata` request sending the ADMIN and DCPATH values
   */
  public createDatabase() {
    let data = {
      fromjs: [
        {
          ADMIN: this.selectedAdminGroup,
          DCPATH: this.dcPath
        }
      ]
    }

    // Get and run service using the selected context name
    let selectedComputeContextName = this.sasJsConfig.contextName

    if (this.selectedComputeContext.length && this.computeContexts.length) {
      const computeContextName = this.getComputeContextName(
        this.selectedComputeContext
      )

      if (computeContextName) {
        selectedComputeContextName = computeContextName
      }
    }

    /**
     * We are overriding default `sasjsConfig` object fields with this object fields.
     * Here we want to run this request using original WEB method.
     * contextName: null is the MUST field for it.
     */
    let overrideConfig = {
      useComputeApi: null,
      contextName: selectedComputeContextName,
      debug: true
    }

    if (this.deployInNewWindow) {
      this.runMakedataInNewWindow({
        contextName: selectedComputeContextName,
        admin: this.selectedAdminGroup,
        dcPath: this.dcPath
      })
    } else {
      this.sasJs
        .request(`services/admin/makedata`, data, overrideConfig, () => {
          this.sasService.shouldLogin.next(true)
        })
        .then((res: any) => {
          this.autodeployDone = true

          try {
            this.makeDataResponse = JSON.stringify(res)
          } catch {
            this.makeDataResponse = res
          }

          if (res.result && res.result.length > 0) {
            this.autoDeployStatus.runMakeData = true
          } else {
            this.autoDeployStatus.runMakeData = false
          }

          if (typeof res.sasjsAbort !== 'undefined') {
            const abortRes = res
            const abortMsg = abortRes.sasjsAbort[0].MSG
            const macMsg = abortRes.sasjsAbort[0].MAC

            this.eventService.showAbortModal('makedata', abortMsg, {
              SYSWARNINGTEXT: abortRes.SYSWARNINGTEXT,
              SYSERRORTEXT: abortRes.SYSERRORTEXT,
              MAC: macMsg,
              _PROGRAM: abortRes._PROGRAM
            })
          }

          if (this.helperService.isStreamingViya())
            this.updateIndexHtmlComputeContext()
        })
        .catch((err: any) => {
          this.eventService.showAbortModal('makedata', JSON.stringify(err))
          this.autoDeployStatus.runMakeData = false
          this.autodeployDone = true

          try {
            this.makeDataResponse = JSON.stringify(err)
          } catch {
            this.makeDataResponse = err
          }
        })
    }
  }

  public runMakedataInNewWindow(params: {
    contextName: string
    admin: string
    dcPath: string
  }) {
    let serverUrl = this.sasjsConfig.serverUrl
    let appLoc = this.sasjsConfig.appLoc
    const execPath = this.sasService.getExecutionPath()
    let contextname = `&_contextname=${params.contextName}`
    let admin = `&admin=${params.admin}`
    let dcPath = `&dcpath=${params.dcPath}`
    // Debug is ALWAYS enabled for makedata — it runs only once during
    // deployment and the full log is needed to diagnose any issues.
    let debug = '&_debug=131'

    let programUrl =
      serverUrl +
      execPath +
      '/?_program=' +
      appLoc +
      '/services/admin/makedata' +
      contextname +
      admin +
      dcPath +
      debug

    window.open(programUrl)

    // Poll for makedata completion. The makedata service self-deletes
    // when it finishes successfully, so we check if it's still present
    // in the admin folder. When it's gone, reload the app fresh.
    this.pollMakedataCompletion()
  }

  private makedataPollInterval: any = null

  private pollMakedataCompletion() {
    if (this.makedataPollInterval) {
      clearInterval(this.makedataPollInterval)
    }

    let attempts = 0
    const maxAttempts = 120 // 10 minutes at 5s intervals

    this.makedataPollInterval = setInterval(async () => {
      attempts++
      console.log(
        `pollMakedataCompletion: checking if makedata is gone (attempt ${attempts}/${maxAttempts})`
      )

      try {
        const makedataGone = await this.sasService.viyaMakedataSuccessfull()
        if (makedataGone) {
          console.log(
            'pollMakedataCompletion: makedata job is gone, reloading app'
          )
          clearInterval(this.makedataPollInterval)
          this.makedataPollInterval = null

          // Reload the app fresh from the SASJobExecution URL
          window.location.href = window.location.href.split('#')[0]
        }
      } catch (err) {
        console.error('pollMakedataCompletion: error checking', err)
      }

      if (attempts >= maxAttempts) {
        console.warn(
          'pollMakedataCompletion: timed out after 10 minutes, stopping poll'
        )
        clearInterval(this.makedataPollInterval)
        this.makedataPollInterval = null
      }
    }, 5000)
  }

  /**
   * Only when on Viya streamed app, this method will update the `contextname` in the `index.html` on the SAS drive
   * This is needed to ensure that the DC will use the same compute context `makedata` service used to run against.
   */
  public async updateIndexHtmlComputeContext() {
    const filenamePath = location.search.split('/').pop()
    const filename = filenamePath?.includes('.') ? filenamePath : undefined

    if (!filename) {
      this.eventService.showAbortModal(
        null,
        'We could not figure out the file name of `index.html` based on the url.'
      )
      return
    }

    const indexHtmlContent = await this.sasService.getFileContent(
      `${this.appLoc}/services`,
      filename
    )

    if (!indexHtmlContent) {
      this.loggerService.error(
        `Failed to get ${filename} at ${this.appLoc}/services`
      )
      return
    }

    const computeContextName = this.getComputeContextName(
      this.selectedComputeContext
    )

    if (!computeContextName) {
      this.loggerService.error(
        `Compute context name not found for ID: ${this.selectedComputeContext} | List: ${JSON.stringify(this.computeContexts)}`
      )
      return
    }

    /* Use a function replacement so $ in computeContextName is treated as a
      literal character. In a string replacement, $ has special meaning
      ($&, $1, $` etc.); a function return value is used verbatim. */
    const updatedContent = indexHtmlContent.replace(
      /contextname="[^"]*"/g,
      () => `contextname="${computeContextName}"`
    )

    await this.sasService
      .updateFileContent(`${this.appLoc}/services`, filename, updatedContent)
      .catch((err: any) => {
        this.loggerService.error(`Failed to update DataController.html: ${err}`)
      })
  }

  public downloadFile(
    content: any,
    filename: string,
    extension: string = 'txt'
  ) {
    this.deployService.downloadFile(content, filename, extension)
  }

  public async onJsonFileChange(event: any) {
    let file = event.target.files[0]

    this.jsonFile = await this.deployService.readFile(file)
  }

  public recreateDatabaseClicked(event: Event) {
    ;(<HTMLInputElement>event.target).checked === true
      ? (this.recreateDatabaseModal = true)
      : ''
  }

  public clearUploadInput(event: Event) {
    this.deployService.clearUploadInput(event)
  }

  public openSasRequestsModal() {
    this.eventService.openRequestsModal()
  }

  public navigateToHome() {
    this.onNavigateToHome.emit()
  }
}