import type { Graph } from './graph';

/**
 * Supported node/edge ID type.
 *
 * "1" and 1 are treated as different IDs.
 */
export type ID = string | number;

export type PlainObject = Record<string, unknown>;

export interface Node<D extends PlainObject> {
  /**
   * Every node in a graph must have a unique ID.
   */
  id: ID;

  /**
   * Node data should be an object with string key and any value.
   */
  data: D;
}

export interface Edge<D extends PlainObject> {
  /**
   * Every edge in a graph must have a unique ID.
   */
  id: ID;

  /**
   * The ID of the starting node of the edge.
   */
  source: ID;

  /**
   * The ID of the ending node of the edge.
   */
  target: ID;

  /**
   * Edge data should be an object with string key and any value.
   */
  data: D;
}

/**
 * TreeData is a nested data structure that contains nodes represent a tree.
 */
export interface TreeData<D> {
  /**
   * Tree node IDs must be unique within the whole graph, not only the current tree.
   */
  id: ID;

  /**
   * An object with string key and any value.
   */
  data: D;

  /**
   * Children nodes. Each node itself is a TreeData object, allowing for an arbitrary depth of nesting.
   */
  children?: TreeData<D>[];
}

/** Options to create a graph. */
export interface GraphOptions<N extends PlainObject, E extends PlainObject> {
  /**
   * An array of node data representing the initial nodes.
   *
   * Each node must have a unique ID.
   *
   * @example
   * [
   *   { id: 1, color: 'red' },
   *   { id: 2, color: 'blue' },
   * ]
   */
  nodes?: Node<N>[];

  /**
   * An array of edge data representing the initial edges.
   *
   * Each edge must have a unique ID.
   *
   * The source and target of each edge must be present in `nodes`.
   *
   * @example
   * [
   *   { id: 9, source: 1, target: 2, weight: 10 },
   * ]
   */
  edges?: Edge<E>[];

  tree?: TreeData<N> | TreeData<N>[];

  /**
   * A listener function which will be called with a {@link GraphChangedEvent} whenever a graph change happened.
   */
  onChanged?: (event: GraphChangedEvent<N, E>) => void;
}

export type TreeIndices<N> = Map<
  string | undefined,
  {
    parentMap: Map<ID, N>;
    childrenMap: Map<ID, Set<N>>;
  }
>;

export interface GraphChangedEvent<
  N extends PlainObject,
  E extends PlainObject,
> {
  /**
   * The {@link Graph} instance which triggered this event.
   */
  graph: Graph<N, E>;

  /**
   * Atomic changes that have occurred in the graph since the last time `graph.onChanged` was triggered.
   *
   * `changes` are ordered by the time they occurred.
   *
   * Each change object is a smallest unit of change that can be made to a graph, including addition, removal, or modification of nodes or edges.
   *
   * You can call {@link Graph.reduceChanges} to reduce them.
   */
  changes: GraphChange<N, E>[];
}

export type GraphChange<N extends PlainObject, E extends PlainObject> =
  | NodeAdded<N>
  | NodeRemoved<N>
  | NodeDataUpdated<N>
  | EdgeAdded<E>
  | EdgeRemoved<E>
  | EdgeUpdated<E>
  | EdgeDataUpdated<E>
  | TreeStructureAttached
  | TreeStructureDetached
  | TreeStructureChanged;

export type NodeAdded<D extends PlainObject> = {
  type: 'NodeAdded';
  value: Node<D>;
};

export type NodeRemoved<D extends PlainObject> = {
  type: 'NodeRemoved';
  value: Node<D>;
};

export type NodeDataUpdated<D extends PlainObject> = {
  type: 'NodeDataUpdated';
  id: ID;
  propertyName?: PropertyKey;
  oldValue: any;
  newValue: any;
};

export type EdgeAdded<D extends PlainObject> = {
  type: 'EdgeAdded';
  value: Edge<D>;
};

export type EdgeRemoved<D extends PlainObject> = {
  type: 'EdgeRemoved';
  value: Edge<D>;
};

export type EdgeUpdated<D extends PlainObject> = {
  type: 'EdgeUpdated';
  id: ID;
  propertyName: 'source' | 'target';
  oldValue: ID;
  newValue: ID;
};

export type EdgeDataUpdated<D extends PlainObject> = {
  type: 'EdgeDataUpdated';
  id: ID;
  propertyName?: PropertyKey;
  oldValue: any;
  newValue: any;
};

export type TreeStructureAttached = {
  type: 'TreeStructureAttached';
  treeKey: string | undefined;
};

export type TreeStructureDetached = {
  type: 'TreeStructureDetached';
  treeKey: string | undefined;
};

export type TreeStructureChanged = {
  type: 'TreeStructureChanged';
  treeKey: string | undefined;
  nodeId: ID;
  oldParentId?: ID;
  newParentId: ID;
};

/** Options to create a GraphView */
export interface GraphViewOptions<
  N extends PlainObject,
  E extends PlainObject,
> {
  /** The original Graph */
  graph: Graph<N, E>;
  nodeFilter?: (node: Node<N>) => boolean;
  edgeFilter?: (edge: Edge<E>, source: Node<N>, target: Node<N>) => boolean;
  /**
   * Cache mode of the GraphView. Defaults to 'none'.
   *
   * - `none`: Use no cache. Filters are applied when reading data. Fast to create but a bit
   * slow to read data.
   *
   * - `auto`: Automatically cache data when view created or graph changed. Fast to read
   * data but takes time to build up cache. You should call `stopAutoCache()` to avoid
   * unnecessary updates if the GraphView is no longer active.
   *
   * - `manual` Manage cache manually. `clearCache()` `refreshCache()` `updateCache()`
   * might be useful.
   */
  cache?: 'none' | 'auto' | 'manual';
}