qr_vitanova/src/app/pages/create-page/create-page.ts

import { Component, inject, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router, RouterLink } from '@angular/router';
import { HttpClient } from '@angular/common/http';
import { FastcheckService } from '../../fastcheck.service';
import { FASTCHECK_API, QR_VITANOVA_API } from '../../api';
import { TranslatePipe } from '../../translate/translate.pipe';
import { TranslationService } from '../../translate/translation.service';

type PaymentMethod = 'sbp';
type Currency = 'RUB';

interface SettingsResponse {
  minAmount?: number;
  maxAmount?: number;
  [key: string]: unknown;
}

interface CreateQrResponse {
  qrId?: string;
  nspkID?: string;
  Payload?: string;    // per API doc (capital P)
  nspkurl?: string;   // actual field name in real responses
  qrUrl?: string;
  qrStatus?: string;
  [key: string]: unknown;
}

interface QrStatusResponse {
  status?: string;    // "NEW" | "APPROVED" | "REJECTED" | "COMPLETED"
  nspkurl?: string;
  nspkID?: string;
  [key: string]: unknown;
}

interface CreateFastcheckResponse {
  fastcheck: string;
  expiration: string;
  code: string;
  Status: boolean;
}

/** Generate a v4-like UUID without crypto dependency. */
function generateUUID(): string {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (Math.random() * 16) | 0;
    return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
  });
}

@Component({
  selector: 'app-create-page',
  imports: [FormsModule, RouterLink, TranslatePipe],
  templateUrl: './create-page.html',
  styleUrl: './create-page.scss'
})
export class CreatePage {
  private http = inject(HttpClient);
  private store = inject(FastcheckService);
  private router = inject(Router);
  private i18n = inject(TranslationService);

  private t(key: string): string { return this.i18n.translate(key); }

  // Limits – updated from settings API on init.
  minAmount = signal<number>(30);
  maxAmount = signal<number>(200_000);

  amount = signal<number | null>(null);
  note = signal<string>('');
  error = signal<string>('');
  loading = signal<boolean>(false);
  settingsLoaded = signal<boolean>(false);

  currency = signal<Currency>('RUB');
  payment = signal<PaymentMethod>('sbp');

  selectPayment(method: PaymentMethod, enabled: boolean): void {
    if (!enabled) return;
    this.payment.set(method);
  }

  selectCurrency(c: Currency, enabled: boolean): void {
    if (!enabled) return;
    this.currency.set(c);
  }

  // QR display state
  qrImageUrl = signal<string | null>(null);
  qrPolling = signal<boolean>(false);
  private pollHandle: ReturnType<typeof setInterval> | null = null;
  private activeQrId = '';

  /** Auth credentials passed by the host page as URL params. */
  private get authKey(): string {
    return new URLSearchParams(window.location.search).get('authorization-key') ?? '';
  }
  private get userId(): string {
    return new URLSearchParams(window.location.search).get('userid-value') ?? '';
  }
  private get sessionId(): string {
    return new URLSearchParams(window.location.search).get('session') ?? '';
  }
  private get reference(): string {
    return new URLSearchParams(window.location.search).get('ref') ?? window.location.hostname;
  }

  constructor() {
    this.loadSettings();
  }

  private loadSettings(): void {
    this.http.get<SettingsResponse>(`${QR_VITANOVA_API}/settings`).subscribe({
      next: (s) => {
        if (typeof s?.minAmount === 'number') this.minAmount.set(s.minAmount);
        if (typeof s?.maxAmount === 'number') this.maxAmount.set(s.maxAmount);
        this.settingsLoaded.set(true);
      },
      error: () => this.settingsLoaded.set(true) // proceed with defaults
    });
  }

  createCheck(): void {
    const val = this.amount();
    if (val !== null && val < this.minAmount()) {
      this.error.set(`${this.t('errors.invalid_amount')} (мин. ${this.minAmount()} ₽)`);
      return;
    }
    if (val !== null && val > this.maxAmount()) {
      this.error.set(`${this.t('errors.invalid_amount')} (макс. ${this.maxAmount().toLocaleString('ru')} ₽)`);
      return;
    }

    this.error.set('');
    this.loading.set(true);

    const headers: Record<string, string> = {};
    if (this.authKey) headers['authorization-key'] = this.authKey;
    if (this.userId)  headers['userid-value']       = this.userId;

    const partnerqrID = generateUUID();

    this.http
      .post<CreateQrResponse>(
        `${QR_VITANOVA_API}/qr`,
        {
          qrtype: 'QRDynamic',
          ...(val !== null ? { amount: val } : {}),
          currency: this.currency(),
          partnerqrID,
          qrDescription: this.note().trim(),
          Userid: this.userId,
          Reference: this.reference
        },
        { headers }
      )
      .subscribe({
        next: (res) => {
          this.loading.set(false);
          const qrId = res?.qrId ?? res?.nspkID ?? '';
          // Real API uses 'nspkurl'; doc says 'Payload' — try both
          const nspkUrl = res?.nspkurl ?? res?.Payload;
          if (qrId || nspkUrl) {
            this.activeQrId = qrId;
            const qrData = nspkUrl
              ? `https://api.qrserver.com/v1/create-qr-code/?size=256x256&margin=8&data=${encodeURIComponent(nspkUrl)}`
              : (res.qrUrl ?? null);
            this.qrImageUrl.set(qrData);
            if (qrId) this.startPolling(qrId);
          } else {
            this.error.set(this.t('errors.payment_failed'));
          }
        },
        error: (err) => {
          this.loading.set(false);
          const msg: string | undefined = err?.error?.message;
          this.error.set(msg ?? this.t('errors.lookup_failed'));
        }
      });
  }

  private startPolling(qrId: string): void {
    this.stopPolling();
    this.qrPolling.set(true);
    this.pollHandle = setInterval(() => {
      this.http.get<QrStatusResponse>(`${QR_VITANOVA_API}/qr/dynamic/${qrId}`)
        .subscribe({
          next: (res) => {
            // API returns status: "NEW" | "APPROVED" | "REJECTED" | "COMPLETED"
            if (res?.status === 'COMPLETED' || res?.status === 'APPROVED') {
              this.stopPolling();
              this.createFastcheck();
            } else if (res?.status === 'REJECTED') {
              this.stopPolling();
              this.error.set(this.t('errors.payment_failed'));
              this.qrImageUrl.set(null);
            }
          },
          error: () => undefined
        });
    }, 3000);
  }

  private stopPolling(): void {
    if (this.pollHandle !== null) {
      clearInterval(this.pollHandle);
      this.pollHandle = null;
    }
    this.qrPolling.set(false);
  }

  private createFastcheck(): void {
    const headers: Record<string, string> = {};
    if (this.sessionId) headers['Authorization'] = JSON.stringify({ sessionID: this.sessionId });

    this.http
      .post<CreateFastcheckResponse>(
        `${FASTCHECK_API}/fastcheck`,
        { amount: this.amount(), currency: this.currency() },
        { headers }
      )
      .subscribe({
        next: (res) => {
          if (res?.fastcheck) {
            this.store.setCreated({
              fastcheck: res.fastcheck,
              code: res.code,
              amount: this.amount() ?? null,
              expiration: res.expiration
            });
          }
          this.router.navigate(['/']);
        },
        error: () => this.router.navigate(['/'])
      });
  }

  onAmountChange(value: number | null): void {
    this.amount.set(value || null);
    if (value && value > 0) this.error.set('');
  }

  onNoteChange(value: string): void {
    this.note.set(value);
  }

  closeQr(): void {
    this.qrImageUrl.set(null);
    this.qrPolling.set(false);
    if (this.pollHandle !== null) {
      clearInterval(this.pollHandle);
      this.pollHandle = null;
    }
  }
}