// backend/src/workflow/definitions/triggers/ticket-updated.trigger.ts
import { createTrigger, Field } from '@opencx/workflows';
import { WorkflowTriggerEnum } from '../../enums/workflow-trigger.enum.ts';
import { ticketPayload } from '../payloads/ticket.payload.ts';

export const ticketUpdatedTrigger = createTrigger(
  WorkflowTriggerEnum.TICKET_UPDATED,
  Field.Object({
    name: 'ticketUpdatedTrigger',
    displayName: 'Ticket Updated',
    description: "Triggered when a ticket's attributes change",
    required: true,
    refable: true,
    relname: 'none',
    properties: {
      ticket: ticketPayload,
      changedFields: Field.Array({
        displayName: 'Changed Fields',
        description:
          'The attribute keys that changed in this update (e.g. "sf_case_Status"). Gate on this to avoid re-triggering when a workflow writes attributes back to the same ticket.',
        required: true,
        refable: true,
        relname: 'none',
        itemField: Field.Text({
          displayName: 'Changed Field',
          description: 'An attribute key that changed',
          required: true,
          refable: true,
          relname: 'none',
        }),
      }),
      previousValues: Field.AnyObject({
        name: 'previousValues',
        displayName: 'Previous Values',
        description:
          'The value each changed attribute had before this update, keyed by attribute. A key that was unset before is absent.',
        required: true,
        refable: true,
        relname: 'none',
      }),
    },
  }),
  null,
  {
    title: 'Ticket Updated',
    description:
      "Triggered when a ticket's attributes change — a Salesforce Case field edited by an agent, a workflow's Update Session Attributes step, or the API. Status, assignee, team and tag changes have their own triggers. A workflow that writes attributes to the same ticket re-triggers itself, so gate the write behind a condition on \"Changed Fields\".",
    iconName: 'ticket',
    env: 'production',
  },
);

import { db } from '#db/db.ts';
import { runCatching } from '#utils/try.ts';
import _ from 'lodash';
import { sql } from 'kysely';
import { type z } from 'zod';
import { WorkflowTriggerPayloadUtils } from '#src/workflow/definitions/payloads/workflow-trigger-payload.utils.ts';
import { ticketUpdatedTrigger } from '#src/workflow/definitions/triggers/ticket-updated.trigger.ts';
import { workflowTrigger_service_triggerByType } from '#src/workflow/services/workflow-trigger/service/trigger-by-type.ts';
import { chatSessionCustomDataSchema } from '../dtos/chat-session.dto.ts';

type CustomDataValue = string | number | boolean;

/**
 * Merge attributes into `chat_sessions.custom_data`, then:
 *   1. fire the Ticket Updated workflow trigger with the keys that actually
 *      moved (an unchanged re-send fires nothing — that diff is what lets a
 *      workflow writing back to the same ticket terminate), and
 *   2. reflect the changed keys onto the org's ticketing system when
 *      `reflectOnIntegration` is on.
 *
 * `clearNullish` mirrors the contact repo: a null value removes the key.
 */
export async function chatSession_repo_mergeCustomData({
  sessionId,
  orgId,
  customData,
  reflectOnIntegration = true,
  clearNullish = false,
}: {
  sessionId: string;
  orgId: string;
  customData: Record<string, CustomDataValue | null | undefined> | z.infer<typeof chatSessionCustomDataSchema>;
  reflectOnIntegration?: boolean;
  clearNullish?: boolean;
}): Promise<{
  data?: { mergedCustomData?: Record<string, any> | null; changedFields: string[] };
  error?: { message: string };
}> {
  const toSet: Record<string, CustomDataValue> = {};
  const keysToClear: string[] = [];
  if (typeof customData === 'object' && customData !== null) {
    for (const key of Object.keys(customData)) {
      const value = customData[key];
      if (value === null || value === undefined) {
        if (clearNullish) keysToClear.push(key);
        continue;
      }
      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
        toSet[key] = value;
      }
    }
  }
  const validation = chatSessionCustomDataSchema.safeParse(toSet);
  if (validation.error) {
    console.log('[mergeCustomData] Custom data is not valid', { validation, customData });
    return { error: { message: 'Custom data is not valid' } };
  }
  if (!sessionId?.trim()) return { error: { message: 'Session ID is required' } };
  if (!customData || typeof customData !== 'object' || Array.isArray(customData)) {
    return { error: { message: 'Custom data must be a valid object' } };
  }
  const serializedData = runCatching(() => JSON.stringify(toSet));
  if (serializedData.error) {
    return { error: { message: 'Custom data contains non-serializable values' } };
  }

  // Pre-read so the trigger only fires on keys that actually moved.
  const prior = await db
    .selectFrom('chat_sessions')
    .select('custom_data')
    .where('id', '=', sessionId)
    .where('copilot_id', '=', orgId)
    .executeTakeFirst();
  const priorData: Record<string, unknown> =
    prior?.custom_data && typeof prior.custom_data === 'object' && !Array.isArray(prior.custom_data)
      ? { ...prior.custom_data }
      : {};

  const merged = sql`COALESCE(custom_data, '{}'::jsonb) || ${JSON.stringify(toSet)}::jsonb`;
  const result = await db
    .updateTable('chat_sessions')
    .set({
      custom_data:
        keysToClear.length > 0 ? sql`(${merged}) - ${keysToClear}::text[]` : merged,
    })
    .where('id', '=', sessionId)
    .where('copilot_id', '=', orgId)
    .returning(['custom_data'])
    .executeTakeFirst();
  if (!result) {
    return {
      error: {
        message:
          'Failed to update session attributes - session not found or does not belong to the organization',
      },
    };
  }
  const mergedData: Record<string, unknown> =
    result.custom_data && typeof result.custom_data === 'object' && !Array.isArray(result.custom_data)
      ? { ...result.custom_data }
      : {};

  const changedFields = [
    ...Object.keys(toSet).filter((key) => !_.isEqual(priorData[key], mergedData[key])),
    ...keysToClear.filter((key) => key in priorData),
  ];
  const previousValues: Record<string, unknown> = {};
  for (const key of changedFields) if (key in priorData) previousValues[key] = priorData[key];

  if (changedFields.length > 0) {
    try {
      await workflowTrigger_service_triggerByType({
        orgId,
        triggerPayload: ticketUpdatedTrigger.$trigger({
          ticket: await WorkflowTriggerPayloadUtils.getTicketPayload({ sessionId }),
          changedFields,
          previousValues,
        }),
      });
    } catch (e) {
      console.error('Failed to trigger ticket updated workflows', { _e: e, orgId, sessionId, changedFields });
    }
  }

  if (reflectOnIntegration && changedFields.length > 0) {
    // (existing lazy-import block, unchanged for intercom/hubspot; new arm:)
    // else if (ticketingSystem === 'salesforce_v2') {
    //   const { SalesforceCaseService } = await import('#src/salesforce-case-integration/salesforce-case.service.ts');
    //   const changed: Record<string, CustomDataValue> = {};
    //   for (const key of changedFields) { const v = toSet[key]; if (v !== undefined) changed[key] = v; }
    //   await SalesforceCaseService.syncCustomDataToCase({ orgId, sessionId, changed });   // Task 3
    // }
  }

  return { data: { mergedCustomData: mergedData, changedFields } };
}

  // ── Case fields changed externally ───────────────────────────────

  /**
   * `case_updated` — any Case field changed in Salesforce (the generic
   * `after update` trigger). Refreshes the session's `sf_case_*` snapshot so
   * attributes stop going stale between lifecycle events; the merge itself
   * fires the Ticket Updated workflow trigger when anything actually moved.
   * Serialized per Case: a later webhook may carry the newest state, so it
   * waits for an in-flight refresh instead of being dropped.
   */
  static async handleCaseUpdated(orgId: string, caseId: string): Promise<void> {
    const session = await db
      .selectFrom('chat_sessions')
      .select(['id', 'contact_id'])
      .where('salesforce_case_id', '=', caseId)
      .where('copilot_id', '=', orgId)
      .executeTakeFirst();
    if (!session) {
      console.log('[SalesforceCase] case_updated for unknown case, ignoring', { orgId, caseId });
      return;
    }
    const lockKey = `salesforce_v2:case:fields-refresh:${orgId}:${caseId}`;
    let token = await RedisLock.acquire({ key: lockKey, ttlSeconds: CASE_FIELDS_REFRESH_LOCK_TTL_SECONDS });
    if (token === null) {
      await RedisLock.waitForRelease({ key: lockKey, maxWaitMs: CASE_FIELDS_REFRESH_LOCK_TTL_SECONDS * 1000 });
      token = await RedisLock.acquire({ key: lockKey, ttlSeconds: CASE_FIELDS_REFRESH_LOCK_TTL_SECONDS });
      if (token === null) {
        console.warn('[SalesforceCase] case_updated refresh still locked, skipping', { orgId, caseId });
        return;
      }
    }
    try {
      await this.syncSalesforceFieldsToCustomData({ orgId, sessionId: session.id, caseId });
    } finally {
      await RedisLock.release({ key: lockKey, token });
    }
  }

      const staleCaseKeys = Object.keys(
        priorSessionCustomData && typeof priorSessionCustomData === 'object' ? priorSessionCustomData : {},
      ).filter((key) => key.startsWith(SF_CASE_CUSTOM_DATA_PREFIX) && !(key in caseCustomData));
      if (Object.keys(caseCustomData).length > 0 || staleCaseKeys.length > 0) {
        const result = await chatSession_repo_mergeCustomData({
          orgId,
          sessionId,
          customData: { ...caseCustomData, ...Object.fromEntries(staleCaseKeys.map((k) => [k, null])) },
          reflectOnIntegration: false,
          clearNullish: true,
        });

trigger OpenCxCaseUpdatedTrigger on Case (after update) {
    // Skip OpenCX's own writes (autofill, workflow actions, owner sync) — the
    // integration user is the DML user for those, and OpenCX already holds
    // that state. Set to the exact Username OpenCX authenticated as.
    String INTEGRATION_USERNAME = '[email protected]';
    if (UserInfo.getUserName() == INTEGRATION_USERNAME) return;
    List<Id> caseIds = new List<Id>();
    for (Case c : Trigger.new) caseIds.add(c.Id);
    if (!caseIds.isEmpty()) {
        OpenSalesforceCaseManagement.sendCaseUpdatedEvents(caseIds);
    }
}

  /**
   * OpenCX → Salesforce write-back for session attributes. A key that names an
   * updateable Case field — `sf_case_<Field>` (the snapshot namespace) or the
   * bare `<Field>` (an agent-typed attribute) — is written to the Case; every
   * other key is ignored. `OwnerId` is owned by assignee sync and never written
   * here. Best-effort: logs and returns on any failure.
   */
  static async syncCustomDataToCase(args: {
    orgId: string;
    sessionId: string;
    changed: Record<string, string | number | boolean>;
  }): Promise<void> {
    const { orgId, sessionId, changed } = args;
    try {
      const org = await db.selectFrom('chatbots').select('ticketing_system').where('id', '=', orgId).executeTakeFirst();
      if (org?.ticketing_system !== TicketingSystemEnum.SALESFORCE_V_2) return;
      const session = await db.selectFrom('chat_sessions').select('salesforce_case_id')
        .where('id', '=', sessionId).where('copilot_id', '=', orgId).executeTakeFirst();
      const caseId = session?.salesforce_case_id;
      if (!caseId) return;
      const updateable = new Map(
        (await SalesforceCaseSDK.describeUpdateableCaseFields(orgId)).map((f) => [f.name, f.type]),
      );
      const record: Record<string, string | number | boolean> = {};
      for (const [key, value] of Object.entries(changed)) {
        const field = key.startsWith(SF_CASE_CUSTOM_DATA_PREFIX) ? key.slice(SF_CASE_CUSTOM_DATA_PREFIX.length) : key;
        const type = updateable.get(field);
        if (!type || field === 'OwnerId') continue;
        if (type === 'boolean') {
          const lowered = String(value).trim().toLowerCase();
          if (lowered !== 'true' && lowered !== 'false') continue;
          record[field] = lowered === 'true';
        } else if (type === 'int' || type === 'double' || type === 'currency' || type === 'percent') {
          const numeric = typeof value === 'number' ? value : Number(String(value).trim());
          if (String(value).trim() === '' || Number.isNaN(numeric)) continue;
          record[field] = numeric;
        } else {
          record[field] = String(value);
        }
      }
      if (Object.keys(record).length === 0) return;
      await SalesforceCaseSDK.updateCase(orgId, caseId, record);
      // Keep the snapshot current without waiting for the Apex echo (which the
      // documented trigger skips for the integration user's own writes).
      await this.syncSalesforceFieldsToCustomData({ orgId, sessionId, caseId });
    } catch (e) {
      console.error('[SalesforceCase] Failed to push session attributes to the Case', {
        orgId, sessionId, keys: Object.keys(changed), _e: e instanceof Error ? e.message : String(e),
      });
    }
  }