import { Component, OnInit, ViewEncapsulation } from '@angular/core'
import { DomSanitizer, SafeHtml } from '@angular/platform-browser'
import { ActivatedRoute, Router } from '@angular/router'
import { AppService, LicenceService, SasService } from '../services'
import { LicenseKeyData } from '../models/LicenseKeyData'
import { RequestWrapperResponse } from '../models/request-wrapper/RequestWrapperResponse'
import {
  detectLicenceKeyProtocolMismatch,
  LicenceKeyProtocolMismatch
} from './utils/detectLicenceKeyProtocolMismatch'
import {
  isCombinedLicenceKey,
  splitCombinedLicenceKey
} from './utils/combinedLicenceKey'
import { getEnabledFeatureLabels } from './utils/getEnabledFeatureLabels'

enum LicenseActions {
  key = 'key',
  register = 'register',
  limit = 'limit',
  update = 'update'
}

@Component({
  selector: 'app-licensing',
  templateUrl: './licensing.component.html',
  styleUrls: ['./licensing.component.scss'],
  encapsulation: ViewEncapsulation.None,
  standalone: false
})
export class LicensingComponent implements OnInit {
  public action: LicenseActions | null = null

  // Each message carries its own icon markup, rather than relying on a
  // sibling element in the template - these render via [innerHTML], which
  // replaces all of the host element's children, so a real <clr-icon>
  // placed in the template around the binding would never survive.
  private readonly errorIcon = `<clr-icon class="is-error" shape="exclamation-circle" size="26"></clr-icon>`

  // SafeHtml, built via bypassSecurityTrustHtml in the constructor (needs
  // DomSanitizer, not yet available in a field initializer) - Angular's
  // default [innerHTML] sanitizer strips unrecognised tags like <clr-icon>
  // (a custom element, not on its standard-tags allowlist), even though it
  // leaves the plain <a> in these same strings alone. Safe to bypass since
  // this content is entirely hardcoded here, never derived from user input.
  public licenseErrors: { [key: string]: SafeHtml }

  public keyError: string | undefined
  public errorDetails: string | undefined
  public missmatchedKey: string | undefined
  public licenceKeyValue: string = ''
  public activationKeyValue: string = ''

  // Purely which INPUT LAYOUT is shown (one field vs two) - not a strict
  // parsing gate. Recognising a combined key doesn't depend on this: see
  // maybeSplitCombinedKey(), called from both layouts' own input handlers.
  public keyFormat: 'combined' | 'legacy' = 'combined'
  public combinedKeyValue: string = ''

  public applyingKeys: boolean = false
  public protocol: string =
    location.protocol === 'https:'
      ? 'HTTPS - secure connection'
      : 'HTTP - insecure connection'

  public syssite = this.appService.syssite
  public currentLicenceKey = this.licenceService.licenceKey
  public currentActivationKey = this.licenceService.activationKey
  public isAppFreeTier = this.licenceService.isAppFreeTier

  public licenseKeyData: LicenseKeyData | null = null

  public inputType: 'file' | 'paste' = 'file'
  public licenceFileError: string | undefined
  public licenceFileLoading: boolean = false
  public licencefile: { filename: string } = {
    filename: ''
  }

  constructor(
    private route: ActivatedRoute,
    private router: Router,
    private licenceService: LicenceService,
    private sasService: SasService,
    private appService: AppService,
    private sanitizer: DomSanitizer
  ) {
    this.licenseErrors = {
      missing: this.sanitizer.bypassSecurityTrustHtml(
        `${this.errorIcon} Licence key is missing - please contact <a class="color-green" href="mailto: [email protected]">[email protected]</a> and enter valid keys below.`
      ),
      expired: this.sanitizer.bypassSecurityTrustHtml(
        `${this.errorIcon} Licence key is expired - please contact <a class="color-green" href="mailto: [email protected]">[email protected]</a> and enter valid keys below.`
      ),
      invalid: this.sanitizer.bypassSecurityTrustHtml(
        `${this.errorIcon} Licence key is invalid - please contact <a class="color-green" href="mailto: [email protected]">[email protected]</a> and enter valid keys below.`
      ),
      missmatch: this.sanitizer.bypassSecurityTrustHtml(
        `${this.errorIcon} Your SYSSITE (below) is not found in the licence key - please contact <a class="color-green" href="mailto: [email protected]">[email protected]</a> and enter valid keys below.`
      )
    }
  }

  ngOnInit(): void {
    this.licenceKeyValue = this.currentLicenceKey || ''
    this.activationKeyValue = this.currentActivationKey || ''

    this.route.queryParams.subscribe((queryParams: any) => {
      this.keyError = queryParams.error
      this.missmatchedKey = queryParams.missmatchId

      if (queryParams.details) {
        this.errorDetails = atob(queryParams.details)
      }
    })

    this.route.params.subscribe((params: any) => {
      let actionInUrl = params.action

      if (actionInUrl) {
        if (Object.values(LicenseActions).includes(actionInUrl)) {
          this.action = actionInUrl
        }
      }
    })

    this.licenseKeyData = this.licenceService.getLicenseKeyData()
  }

  public async trimKeys() {
    this.licenceKeyValue = this.licenceKeyValue.trim()
    this.activationKeyValue = this.activationKeyValue.trim()

    // Auto-detect regardless of keyFormat - a combined key pasted into the
    // legacy "Licence key" field on its own still gets recognised and
    // splits into both fields, rather than requiring the toggle to match.
    await this.maybeSplitCombinedKey(this.licenceKeyValue)
    await this.refreshKeyPreview()
  }

  public async onCombinedKeyInput() {
    this.combinedKeyValue = this.combinedKeyValue.trim()

    // The combined field is the sole source of truth for
    // licenceKeyValue/activationKeyValue in this layout - if it's been
    // cleared (or isn't a recognisable combined key), there's no key data
    // to preview, so clear rather than leave a stale split from an earlier
    // paste (which would otherwise keep decrypting to that old key).
    const wasSplit = await this.maybeSplitCombinedKey(this.combinedKeyValue)
    if (!wasSplit) {
      this.licenceKeyValue = ''
      this.activationKeyValue = ''
    }

    await this.refreshKeyPreview()
  }

  // Decrypts whatever's currently in licenceKeyValue/activationKeyValue
  // purely to preview its details (valid_until, users_allowed, ...) before
  // the user ever clicks Apply - decryptLicenseKey() has no side effects,
  // so this is safe to call speculatively on every input change. Clears
  // rather than leaves stale data on failure/incomplete input, since
  // showing a previous key's details next to a since-changed paste would
  // be actively misleading, not just uninformative.
  private async refreshKeyPreview(): Promise<void> {
    if (!this.licenceKeyValue || !this.activationKeyValue) {
      this.licenseKeyData = null
      return
    }

    try {
      this.licenseKeyData = await this.licenceService.decryptLicenseKey(
        this.licenceKeyValue,
        this.activationKeyValue
      )
    } catch {
      this.licenseKeyData = null
    }
  }

  public toggleKeyFormat() {
    this.keyFormat = this.keyFormat === 'combined' ? 'legacy' : 'combined'
  }

  // Shared by both input layouts' own handlers above - populates
  // licenceKeyValue/activationKeyValue when value is recognisably a
  // combined key, regardless of which field it was typed/pasted into.
  private async maybeSplitCombinedKey(value: string): Promise<boolean> {
    if (!isCombinedLicenceKey(value)) return false

    const split = await splitCombinedLicenceKey(value)
    if (!split) return false

    this.licenceKeyValue = split.licenceKey
    this.activationKeyValue = split.activationKey
    return true
  }

  public copySyssite(copyIconRef: any, copyTooltip: any, syssite: string[]) {
    const syssiteString = syssite.join('\n')

    navigator.clipboard.writeText(syssiteString).then(() => {
      copyIconRef.setAttribute('shape', 'check')
      copyIconRef.setAttribute('class', 'is-success')
      copyTooltip.innerText = 'Copied!'

      setTimeout(() => {
        copyIconRef.setAttribute('shape', 'copy')
        copyIconRef.removeAttribute('class')
        copyTooltip.innerText = 'Copy to clipboard'
      }, 1000)
    })
  }

  public applyKeys() {
    this.applyingKeys = true

    let table = {
      keyupload: [
        {
          ACTIVATION_KEY: this.activationKeyValue,
          LICENCE_KEY: this.licenceKeyValue
        }
      ]
    }

    this.sasService
      .request('admin/registerkey', table)
      .then((res: RequestWrapperResponse) => {
        if (
          res.adapterResponse.return &&
          res.adapterResponse.return[0] &&
          res.adapterResponse.return[0].MSG === 'SUCCESS'
        ) {
          this.router.navigateByUrl('/').then(() => {
            window.location.reload()
          })
        }
      })
      .finally(() => {
        this.applyingKeys = false
      })
  }

  public onFileCapture(event: any, dropped = false) {
    let file = dropped ? event[0] : event.target.files[0]
    this.licencefile.filename = file.name

    if (!file) return

    this.licenceFileLoading = true

    const reader = new FileReader()

    reader.onload = async (evt) => {
      this.licenceFileError = 'Error reading file.'

      if (!evt || !evt.target) return
      if (evt.target.readyState != 2) return
      if (evt.target.error) return
      if (!evt.target.result) return

      this.licenceFileLoading = false
      this.licenceFileError = undefined

      const fileArr = evt.target.result.toString().trim().split('\n')

      // A combined-key file is a single line - splits into both fields.
      // Anything else keeps the existing 2-line legacy file behaviour.
      if (
        fileArr.length !== 1 ||
        !(await this.maybeSplitCombinedKey(fileArr[0]))
      ) {
        this.activationKeyValue = fileArr[1]
        this.licenceKeyValue = fileArr[0]
      }

      await this.refreshKeyPreview()
    }

    reader.readAsText(file)
  }

  public switchType(type: 'paste' | 'file') {
    this.inputType = type
  }

  get disableApplyButton(): boolean {
    if (this.licenceKeyValue.length < 1 || this.activationKeyValue.length < 1)
      return true
    if (
      this.licenceKeyValue === this.currentLicenceKey &&
      this.activationKeyValue === this.currentActivationKey
    )
      return true
    // A protocol mismatch is a deterministic predictor of decrypt failure
    // (see detectLicenceKeyProtocolMismatch's own doc comment) - submitting
    // anyway would just trade this specific warning for a generic "invalid
    // key" error after a round trip to the backend.
    if (this.protocolMismatch) return true

    return false
  }

  // Warns before the user even submits - covers both the file-upload and
  // paste tabs, since both feed licenceKeyValue/activationKeyValue. Passes
  // actual WebCrypto availability, not location.protocol - see
  // detectLicenceKeyProtocolMismatch's own doc comment for why (localhost
  // is a secure context even over http).
  get protocolMismatch(): LicenceKeyProtocolMismatch {
    return detectLicenceKeyProtocolMismatch(
      this.licenceKeyValue,
      this.activationKeyValue,
      !!(window.crypto && window.crypto.subtle)
    )
  }

  get enabledFeatures(): string[] {
    return getEnabledFeatureLabels(this.licenseKeyData?.features)
  }
}