import {
  ChangeDetectionStrategy,
  Component,
  computed,
  input,
  linkedSignal,
  output
} from '@angular/core';
import { AclRule, convertRulesToPolicyTxt } from '@allianz/taly-acl';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { AclIconName, copyToClipboard } from '@allianz/taly-acl/angular';

@Component({
  selector: 'acl-policy-editor',
  templateUrl: './policy-editor.component.html',
  styleUrls: ['./policy-editor.component.scss'],
  standalone: false,
  changeDetection: ChangeDetectionStrategy.OnPush
})
export class PolicyEditorComponent {
  policy = input<AclRule[]>([]);
  persistPolicyUrl = input<string>('');
  changed = output<AclRule[]>();

  mutablePolicy = linkedSignal(() => this.policy());
  toggleAllState = computed(() => this.hasActiveNonDefaultRules());
  aclIconName = AclIconName;

  dropRule(event: CdkDragDrop<AclRule>) {
    const policy = [...this.mutablePolicy()];
    const draggedRule = policy[event.previousIndex];
    if (!draggedRule) {
      throw new Error(`Could not move rule with index ${event.previousIndex}`);
    }

    policy.splice(event.previousIndex, 1);

    const indexForFirstDefaultRule = policy.findIndex((rule) => rule.defaultRule);

    if (indexForFirstDefaultRule === -1) {
      policy.splice(event.currentIndex, 0, draggedRule);
    } else {
      const currentIndex = Math.min(indexForFirstDefaultRule, event.currentIndex);
      policy.splice(currentIndex, 0, draggedRule);
    }

    this.mutablePolicy.set(policy);
    this.requestUpdate();
  }

  private hasActiveNonDefaultRules() {
    const mutablePolicy = this.mutablePolicy();
    if (mutablePolicy.length === 0) {
      return true;
    }
    return mutablePolicy.filter((rule) => !rule.defaultRule).some((rule) => rule.active);
  }

  requestUpdate() {
    this.changed.emit(this.mutablePolicy());
  }

  toggleAll() {
    const policy = this.mutablePolicy();
    if (policy.length === 0) {
      return;
    }
    const newState = !this.hasActiveNonDefaultRules();
    this.mutablePolicy.set(
      policy.map((rule) => (rule.defaultRule ? rule : { ...rule, active: newState }))
    );
    this.requestUpdate();
  }

  copyToClipboard() {
    const policyString = convertRulesToPolicyTxt(this.mutablePolicy());

    copyToClipboard(policyString);
  }

  persistPolicy() {
    const policyString = convertRulesToPolicyTxt(this.mutablePolicy());

    fetch(this.persistPolicyUrl(), { method: 'POST', body: policyString, credentials: 'include' });
  }

  createRule() {
    this.mutablePolicy.set([
      { active: true, condition: '', path: '*', state: 'visible', defaultRule: false },
      ...this.mutablePolicy()
    ]);
    this.requestUpdate();
  }

  duplicateRule(rule: AclRule, index: number) {
    const policy = [...this.mutablePolicy()];
    const indexForFirstDefaultRule = policy.findIndex((r) => r.defaultRule);
    const insertIndex =
      indexForFirstDefaultRule === -1 ? index : Math.min(indexForFirstDefaultRule, index);

    policy.splice(insertIndex, 0, { ...rule, defaultRule: false });

    this.mutablePolicy.set(policy);
    this.requestUpdate();
  }

  removeRule(index: number) {
    const newRules = [...this.mutablePolicy()];
    newRules.splice(index, 1);
    this.mutablePolicy.set(newRules);
    this.requestUpdate();
  }
}