import type { Loadable } from './loadable.ts';

type LoadableKeys<T extends Record<string, unknown>> = {
  [K in keyof T]: T[K] extends Loadable<any> ? K : never;
}[keyof T];

type Simplify<T> = { [K in keyof T]: T[K] } & {};

type FieldValues<T extends Record<string, unknown>> = Simplify<{
  [K in LoadableKeys<T>]: T[K] extends Loadable<infer V> ? V : never;
}>;

function isLoadable(value: unknown): value is Loadable<unknown> {
  return (
    typeof value === 'object' &&
    value !== null &&
    typeof (value as any).load === 'function' &&
    typeof (value as any).store === 'function'
  );
}

const SHARED = Symbol.for('moroutine.shared');

/** A named group of shared-memory fields with bulk `load()`/`store()` access. */
export class SharedStruct<T extends Record<string, unknown>> implements Loadable<FieldValues<T>> {
  readonly fields: T;

  constructor(fields: T) {
    this.fields = fields;
  }

  load(): FieldValues<T> {
    const result = {} as any;
    for (const key in this.fields) {
      const field = this.fields[key];
      if (isLoadable(field)) {
        result[key] = field.load();
      }
    }
    return result;
  }

  store(values: FieldValues<T>): void {
    for (const key in this.fields) {
      const field = this.fields[key];
      if (isLoadable(field)) {
        if (key in (values as any)) {
          field.store((values as any)[key]);
        }
      }
    }
  }

  [SHARED](): { tag: string; fields: Record<string, unknown> } {
    const serializedFields: Record<string, unknown> = {};
    for (const key in this.fields) {
      const field = this.fields[key];
      if (typeof field === 'object' && field !== null && SHARED in field) {
        serializedFields[key] = (field as any)[SHARED]();
      }
    }
    return { tag: 'SharedStruct', fields: serializedFields };
  }
}