import { WallaField } from '@wallaform/custom-field-sdk';

const field = new WallaField(options?: WallaFieldOptions);

field.onInit(callback: (payload: FieldInitPayload) => void): void

field.onInit(({ properties, value, theme, locale, fieldInfo, formContext, mode }) => {
  document.body.style.fontFamily = theme.fontFamily;
  if (value) restoreState(value);
  field.setHeight(document.body.scrollHeight);
});

field.onValidate(callback: ValidateCallback): void

field.onValidate((submitType) => {
  if (!currentValue) {
    return { valid: false, errors: [{ message: 'Required' }] };
  }
  return { valid: true };
});

field.onValueSet(callback: (value: unknown) => void): void

field.onValueSet((value) => {
  applyValue(value);
});

field.onDestroy(callback: () => void): void

field.onDestroy(() => {
  clearInterval(myTimer);
  myWebSocket.close();
});

field.onFocus(callback: () => void): void

field.onFocus(() => {
  document.getElementById('main-input').focus();
});

field.onFormValuesChanged(callback: (values: Record<string, unknown>) => void): void

field.onFormValuesChanged((values) => {
  const total = Object.values(values)
    .filter(v => typeof v === 'number')
    .reduce((sum, v) => sum + v, 0);
  field.setValue(total);
});

field.setValue(value: unknown): void

field.setValue('#FF6B6B');
field.setValue({ hex: '#FF6B6B', opacity: 0.8 });
field.setValue(['option1', 'option2']);

field.setHeight(height: number): void

field.setHeight(document.body.scrollHeight);

field.uploadBlob(
  data: ArrayBuffer,
  mimeType: string,
  filename?: string
): Promise<{ url: string }>

const canvas = document.getElementById('signature');
const blob = await new Promise(resolve => canvas.toBlob(resolve, 'image/png'));
const buffer = await blob.arrayBuffer();

const { url } = await field.uploadBlob(buffer, 'image/png', 'signature.png');

field.reportError(error: { message: string; recoverable: boolean }): void

field.reportError({
  message: 'Failed to load external data source',
  recoverable: true,
});

field.destroy(): void

field.destroy();

field.getProperties<T = Record<string, unknown>>(): T

interface MyProperties {
  placeholder: string;
  maxLength: number;
}
const props = field.getProperties<MyProperties>();

field.getTheme(): WallaFieldTheme

field.getLocale(): string

field.getFieldInfo(): WallaFieldInfo

field.getFormContext(): { fields: FieldSummary[]; values: Record<string, unknown> }

field.getObservedFields(): ObservedFieldRef[]

field.onInit(({ observedFields, formContext }) => {
  for (const ref of observedFields) {
    if (ref.kind === 'field') {
      const value = formContext.values[ref.id];
      // ...
    } else {
      const summary = formContext.fields.find(f => f.label === ref.label);
      // ...
    }
  }
});

field.isConnected(): boolean

field.getVersion(): string

interface WallaFieldOptions {
  debug?: boolean;
}

interface FieldInitPayload {
  protocolVersion: number;
  mode: 'live' | 'preview';
  fieldInfo: WallaFieldInfo;
  properties: Record<string, unknown>;
  observedFields: ObservedFieldRef[];
  value: unknown | null;
  theme: WallaFieldTheme;
  locale: string;
  formContext: {
    fields: FieldSummary[];
    values: Record<string, unknown>;
  };
}

interface WallaFieldTheme {
  background: string;        // Form background color
  foreground: string;        // Primary text color
  primary: string;           // Accent/brand color
  primaryForeground: string; // Text color on primary background
  field: string;             // Input field background color
  fieldForeground: string;   // Input placeholder color
  border: string;            // Border color
  accent: string;            // Secondary accent color
  fontFamily: string;        // CSS font-family value
  borderRadius: string;      // CSS border-radius value
  direction: 'ltr' | 'rtl'; // Text direction
}

interface WallaFieldInfo {
  fieldId: string;
  formId: string;
  label: string;
}

interface WallaFieldValidationResult {
  valid: boolean;
  errors?: WallaFieldValidationError[];
}

interface WallaFieldValidationError {
  message: string;
  itemId?: string;
}

interface FieldSummary {
  id: string;
  fieldType: string;
  label: string;
  description?: string;
  isRequired: boolean;
  properties: Record<string, unknown>;
  customField?: {
    typeId: string;
    typeName: string;
    outputSchema: Record<string, unknown>;
  };
}

type ObservedFieldRef =
  | { kind: 'field';  id: string }     // 일반 폼 필드, id로 식별
  | { kind: 'hidden'; label: string }; // Hidden 필드 (URL 쿼리 파라미터), 작성자가 정의한 label로 식별

type ValidateCallback = (
  submitType: 'next' | 'submit',
) => WallaFieldValidationResult | Promise<WallaFieldValidationResult>;

type ObserveFieldsMode = 'none' | 'all' | 'configured';

interface FieldRpcApi {
  init(payload: FieldInitPayload): void;
  destroy(): void;
  focus(): void;
  setValue(value: unknown): void;
  onFormValuesChanged(values: Record<string, unknown>): void;
  validate(submitType: 'next' | 'submit'): Promise<WallaFieldValidationResult>;
}

interface HostRpcApi {
  setValue(value: unknown): void;
  setHeight(height: number): void;
  uploadBlob(data: ArrayBuffer, mimeType: string, filename?: string): Promise<{ url: string }>;
  reportError(error: { message: string; recoverable: boolean }): void;
}

export {
  WallaField,
  type WallaFieldTheme,
  type WallaFieldInfo,
  type WallaFieldOptions,
  type WallaFieldValidationError,
  type WallaFieldValidationResult,
  type ValidateCallback,
  type FieldInitPayload,
  type FieldRpcApi,
  type HostRpcApi,
  type FieldSummary,
  type WallaPortInitMessage,
  type ObserveFieldsMode,
} from '@wallaform/custom-field-sdk';