import { TGTCoreSDK } from '@tgtone/core-sdk';

const core = new TGTCoreSDK({
  apiUrl: 'https://tgtone-console-backend.run.app/api',
  getToken: () => localStorage.getItem('tgtone_auth_token'),
  debug: true // Opcional: logs en consola
});

import { TGTAuthClient } from '@tgtone/auth-sdk';
import { TGTCoreSDK } from '@tgtone/core-sdk';

// 1. Autenticación
const auth = new TGTAuthClient({
  identityUrl: 'https://identity.tgtone.cl',
  appDomain: window.location.hostname
});

const session = await auth.checkSession();

// 2. Core SDK con token del Auth
const core = new TGTCoreSDK({
  apiUrl: 'https://tgtone-console-backend.run.app/api',
  getToken: () => localStorage.getItem('tgtone_auth_token')
});

// 3. Usar módulos
const tenant = await core.tenants.get(session.tenantId);
console.log('Tenant:', tenant.name);

interface TGTCoreConfig {
  // URL base del backend (sin trailing slash)
  apiUrl: string;
  
  // Función para obtener el token JWT
  getToken: () => string | null;
  
  // Habilitar logs de debug (default: false)
  debug?: boolean;
  
  // Timeout de requests en ms (default: 30000)
  timeout?: number;
  
  // Headers adicionales
  headers?: Record<string, string>;
}

import { TGTCoreError } from '@tgtone/core-sdk';

try {
  const tenant = await core.tenants.get('invalid-id');
} catch (error) {
  if (error instanceof TGTCoreError) {
    if (error.isUnauthorized()) {
      console.log('Token expirado, redirigir a login');
    } else if (error.isNotFound()) {
      console.log('Tenant no encontrado');
    } else {
      console.error('Error API:', error.message);
    }
  }
}

const tenant = await core.tenants.get(tenantId);
await core.tenants.update(tenantId, { name: 'Nueva Empresa' });
const stats = await core.tenants.getStats(tenantId);

// Listar usuarios de un tenant
const users = await core.users.list(tenantId);

// Invitar nuevo usuario
await core.users.invite({
  email: 'nuevo@empresa.cl',
  firstName: 'Juan',
  lastName: 'Pérez',
  tenantId,
  organizationalRole: 'admin',
  applicationAccess: [
    { applicationId: 'app-uuid', roleId: 'role-uuid' }
  ]
});

// Actualizar usuario
await core.users.update(userId, {
  firstName: 'Juan Carlos',
  organizationalRole: 'user'
});

// Actualizar permisos de aplicaciones
await core.users.updatePermissions(userId, {
  permissions: [
    { applicationId: 'app-uuid', roleId: 'role-uuid' }
  ]
});

// Obtener permisos del usuario autenticado
const permissions = await core.users.getMyPermissions();
// Resultado:
// {
//   userId: 'user-uuid',
//   tenantId: 'tenant-uuid',
//   organizationalRole: 'admin',
//   applications: [
//     {
//       applicationKey: 'crm',
//       applicationName: 'Zenith CRM',
//       roleKey: 'vendedor',
//       roleName: 'Vendedor Senior',
//       permissions: {
//         modules: {
//           contacts: { read: true, create: true, update: true, delete: true },
//           tickets: { read: true, create: true, assign: true, close: true },
//           reports: { read: true, export: true }
//         }
//       },
//       level: 1
//     }
//   ]
// }

// Verificar permisos con helper
import { PermissionsChecker } from '@tgtone/core-sdk';

const checker = new PermissionsChecker(permissions);

// Verificar permiso específico
if (checker.can('crm', 'contacts', 'create')) {
  console.log('Puede crear contactos');
}

// Verificar múltiples permisos
if (checker.canAll('crm', 'tickets', ['read', 'close'])) {
  console.log('Puede ver y cerrar tickets');
}

// Obtener acciones permitidas
const allowedActions = checker.getAllowedActions('crm', 'contacts');
// ['read', 'create', 'update', 'delete']

// Verificar rol organizacional
if (checker.isAdminOrOwner()) {
  console.log('Acceso completo a la consola');
}

// Verificar permisos específicos
const canCreateContact = permissions.applications
  .find(app => app.applicationKey === 'crm')
  ?.permissions?.includes('contacts.create');

// Reenviar invitación
await core.users.resendInvitation(userId);

const logs = await core.activity.getLogsFiltered(tenantId, {
  level: 'error',
  startDate: '2025-01-01'
});

await core.activity.log({
  action: 'user.login',
  level: 'success',
  resource: 'user',
  resourceId: userId
});

// Backend: Crear notificación
await core.notifications.create({
  appId: 'baco',
  title: 'Análisis completado',
  message: 'Barrica B-001 lista',
  type: 'success'
});

// Frontend: Polling cada 15s
const { notifications } = await core.notifications.getNotifications({ appId: 'baco' });
const { count } = await core.notifications.getUnreadCount('baco');

// Marcar como leída
await core.notifications.markAsRead(notificationId);

// Calcular total a pagar
const total = await core.payments.calculateTotal();
console.log('Total:', total.totalAmount);

// Crear pago e ir a WebPay
const payment = await core.payments.create({
  tenantId: 'tenant-uuid',
  description: 'Suscripción mensual - CRM Pro',
  operationType: 'SUBSCRIPTION_PURCHASE',
  items: [
    {
      subscriptionId: 'sub-uuid',
      planId: 'plan-uuid',
      description: 'CRM Pro - 10 usuarios',
      quantity: 10,
      unitPrice: 9990,
      totalPrice: 99900
    }
  ]
});

// Redirigir a WebPay
window.location.href = payment.webpayUrl;

// Obtener estado del pago (después del callback)
const paymentStatus = await core.payments.get(payment.payment.id);
console.log('Estado:', paymentStatus.status); // AUTHORIZED, FAILED, etc.