import { Bytes } from './bytes.ts';
import { SharedString } from './string.ts';
import { Int8 } from './int8.ts';
import { Uint8 } from './uint8.ts';
import { Int16 } from './int16.ts';
import { Uint16 } from './uint16.ts';
import { Int32 } from './int32.ts';
import { Uint32 } from './uint32.ts';
import { Int64 } from './int64.ts';
import { Uint64 } from './uint64.ts';
import { Bool } from './bool.ts';
import { Int8Atomic } from './int8-atomic.ts';
import { Uint8Atomic } from './uint8-atomic.ts';
import { Int16Atomic } from './int16-atomic.ts';
import { Uint16Atomic } from './uint16-atomic.ts';
import { Int32Atomic } from './int32-atomic.ts';
import { Uint32Atomic } from './uint32-atomic.ts';
import { Int64Atomic } from './int64-atomic.ts';
import { Uint64Atomic } from './uint64-atomic.ts';
import { BoolAtomic } from './bool-atomic.ts';
import { Mutex } from './mutex.ts';
import { RwLock } from './rwlock.ts';

/** A schema token describing a shared-memory type. Callable to create a standalone instance. */
export interface Descriptor<T> {
  (): T;
  byteSize: number;
  byteAlignment: number;
  _class: new (buffer: SharedArrayBuffer, byteOffset: number) => T;
}

function makeDescriptor<T>(
  factory: () => T,
  byteSize: number,
  byteAlignment: number,
  _class: new (buffer: SharedArrayBuffer, byteOffset: number) => T,
): Descriptor<T> {
  return Object.assign(factory, { byteSize, byteAlignment, _class });
}

/** Non-atomic shared primitives. Use inside a lock for thread safety. */
export const int8: Descriptor<Int8> = makeDescriptor(() => new Int8(), Int8.byteSize, Int8.byteAlignment, Int8);
export const uint8: Descriptor<Uint8> = makeDescriptor(() => new Uint8(), Uint8.byteSize, Uint8.byteAlignment, Uint8);
export const int16: Descriptor<Int16> = makeDescriptor(() => new Int16(), Int16.byteSize, Int16.byteAlignment, Int16);
export const uint16: Descriptor<Uint16> = makeDescriptor(
  () => new Uint16(),
  Uint16.byteSize,
  Uint16.byteAlignment,
  Uint16,
);
export const int32: Descriptor<Int32> = makeDescriptor(() => new Int32(), Int32.byteSize, Int32.byteAlignment, Int32);
export const uint32: Descriptor<Uint32> = makeDescriptor(
  () => new Uint32(),
  Uint32.byteSize,
  Uint32.byteAlignment,
  Uint32,
);
export const int64: Descriptor<Int64> = makeDescriptor(() => new Int64(), Int64.byteSize, Int64.byteAlignment, Int64);
export const uint64: Descriptor<Uint64> = makeDescriptor(
  () => new Uint64(),
  Uint64.byteSize,
  Uint64.byteAlignment,
  Uint64,
);
export const bool: Descriptor<Bool> = makeDescriptor(() => new Bool(), Bool.byteSize, Bool.byteAlignment, Bool);

/** Atomic shared primitives. Thread-safe without a lock. */
export const int8atomic: Descriptor<Int8Atomic> = makeDescriptor(
  () => new Int8Atomic(),
  Int8Atomic.byteSize,
  Int8Atomic.byteAlignment,
  Int8Atomic,
);
export const uint8atomic: Descriptor<Uint8Atomic> = makeDescriptor(
  () => new Uint8Atomic(),
  Uint8Atomic.byteSize,
  Uint8Atomic.byteAlignment,
  Uint8Atomic,
);
export const int16atomic: Descriptor<Int16Atomic> = makeDescriptor(
  () => new Int16Atomic(),
  Int16Atomic.byteSize,
  Int16Atomic.byteAlignment,
  Int16Atomic,
);
export const uint16atomic: Descriptor<Uint16Atomic> = makeDescriptor(
  () => new Uint16Atomic(),
  Uint16Atomic.byteSize,
  Uint16Atomic.byteAlignment,
  Uint16Atomic,
);
export const int32atomic: Descriptor<Int32Atomic> = makeDescriptor(
  () => new Int32Atomic(),
  Int32Atomic.byteSize,
  Int32Atomic.byteAlignment,
  Int32Atomic,
);
export const uint32atomic: Descriptor<Uint32Atomic> = makeDescriptor(
  () => new Uint32Atomic(),
  Uint32Atomic.byteSize,
  Uint32Atomic.byteAlignment,
  Uint32Atomic,
);
export const int64atomic: Descriptor<Int64Atomic> = makeDescriptor(
  () => new Int64Atomic(),
  Int64Atomic.byteSize,
  Int64Atomic.byteAlignment,
  Int64Atomic,
);
export const uint64atomic: Descriptor<Uint64Atomic> = makeDescriptor(
  () => new Uint64Atomic(),
  Uint64Atomic.byteSize,
  Uint64Atomic.byteAlignment,
  Uint64Atomic,
);
export const boolatomic: Descriptor<BoolAtomic> = makeDescriptor(
  () => new BoolAtomic(),
  BoolAtomic.byteSize,
  BoolAtomic.byteAlignment,
  BoolAtomic,
);

/** Shared-memory locks. */
export const mutex: Descriptor<Mutex> = makeDescriptor(() => new Mutex(), Mutex.byteSize, Mutex.byteAlignment, Mutex);
export const rwlock: Descriptor<RwLock> = makeDescriptor(
  () => new RwLock(),
  RwLock.byteSize,
  RwLock.byteAlignment,
  RwLock,
);

export interface BytesDescriptor extends Bytes {
  byteSize: number;
  byteAlignment: number;
  _class: typeof Bytes;
  _size: number;
}

/**
 * Creates a fixed-size shared byte buffer. Acts as both a standalone factory and a schema descriptor.
 * @param size - The buffer capacity in bytes.
 * @returns A {@link Bytes} instance with descriptor metadata for use with `shared()`.
 */
export function bytes(size: number): BytesDescriptor {
  const instance = new Bytes(size);
  return Object.assign(instance, {
    byteSize: size,
    byteAlignment: Bytes.byteAlignment,
    _class: Bytes,
    _size: size,
  }) as BytesDescriptor;
}

export interface StringDescriptor extends SharedString {
  byteSize: number;
  byteAlignment: number;
  _class: typeof SharedString;
  _maxBytes: number;
}

/**
 * Creates a variable-length shared UTF-8 string with a max byte length. Acts as both a standalone factory and a schema descriptor.
 * @param maxBytes - Maximum number of bytes for the encoded string.
 * @returns A {@link SharedString} instance with descriptor metadata for use with `shared()`.
 */
export function string(maxBytes: number): StringDescriptor {
  const instance = new SharedString(maxBytes);
  return Object.assign(instance, {
    byteSize: 4 + maxBytes,
    byteAlignment: SharedString.byteAlignment,
    _class: SharedString,
    _maxBytes: maxBytes,
  }) as StringDescriptor;
}