import { assign, fromCallback, setup, type Snapshot } from 'xstate';

import { createDecorator, IInstantiationService } from '#/_base/di/instantiation';
import type { Event } from '#/_base/event';
import { registerEvent2Class } from '#/app/event/event2';
import {
  AgentActorService,
  type AgentActorContext,
  type AgentActorRestoreEvent,
} from '#/agent/actorService/agentActorService';
import { IAgentContextMemoryService } from '#/agent/contextMemory/contextMemory';
import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
import { IAgentToolPolicyService } from '#/agent/toolPolicy/toolPolicy';
import { IAgentReminderService } from '#/features/reminder/reminderService';
import { MAIN_AGENT_ID } from '#/session/agentLifecycle/agentLifecycle';
import { IEventDispatcher } from '#/state/eventDispatcher';

import { TODO_LIST_TOOL_NAME, readTodoItems, type TodoItem } from './todoItem';
import { TODO_LIST_REMINDER_VARIANT, todoListStaleReminder } from './todoListReminder';
import { ToolsUpdateStore, type TodoState } from './todoOps';

import '#/agent/contextMemory/conversationTime';

registerEvent2Class(ToolsUpdateStore);

interface TodoActorContext {
  readonly todos: TodoState;
  readonly runtime: AgentActorContext<TodoState>;
  readonly used: boolean;
}

interface TodoCommitEvent {
  readonly type: 'todo.commit';
  readonly todos: TodoState;
}

interface TodoUsedEvent {
  readonly type: 'todo.used';
}

type TodoActorSnapshot = Snapshot<unknown> & { readonly context: TodoActorContext };

const todoReminder = fromCallback(({
  input,
}: {
  input: {
    readonly runtime: AgentActorContext<TodoState>;
  };
}) => {
  if (input.runtime.agent.agentId !== MAIN_AGENT_ID) return;
  const injector = input.runtime.get(IAgentReminderService);
  const memory = input.runtime.get(IAgentContextMemoryService);
  const toolPolicy = input.runtime.get(IAgentToolPolicyService);
  const registration = injector.register(TODO_LIST_REMINDER_VARIANT, () =>
    todoListStaleReminder({
      active: toolPolicy.isToolActive(TODO_LIST_TOOL_NAME, 'builtin'),
      history: memory.get(),
      todos: input.runtime.getState(),
    }),
  );
  return () => { registration.dispose(); };
});

const todoActorLogic = setup({
  types: {} as {
    context: TodoActorContext;
    input: AgentActorContext<TodoState>;
    events: TodoCommitEvent | TodoUsedEvent | AgentActorRestoreEvent;
  },
  actors: { todoReminder },
}).createMachine({
  context: ({ input }) => ({ todos: [], runtime: input, used: false }),
  initial: 'beforeRestore',
  states: {
    beforeRestore: {
      on: {
        'runtime.restore': [
          { target: 'reminding', guard: ({ context }) => context.used },
          { target: 'active' },
        ],
        'todo.used': { actions: assign({ used: true }) },
      },
    },
    active: {
      on: {
        'todo.used': { target: 'reminding', actions: assign({ used: true }) },
      },
    },
    reminding: {
      invoke: {
        src: 'todoReminder',
        input: ({ context }) => ({ runtime: context.runtime }),
      },
    },
  },
  on: {
    'todo.commit': {
      actions: assign({ todos: ({ event }) => event.todos }),
    },
  },
});

export interface IAgentTodoService {
  readonly _serviceBrand: undefined;
  readonly onDidChange: Event<TodoState>;
  get(): readonly TodoItem[];
  replace(todos: readonly TodoItem[]): Promise<void>;
  clear(): Promise<void>;
}

export const IAgentTodoService = createDecorator<IAgentTodoService>('agentTodoService');

export class AgentTodoService extends AgentActorService<TodoState> implements IAgentTodoService {
  declare readonly _serviceBrand: undefined;
  readonly onDidChange: IAgentTodoService['onDidChange'];

  private readonly actor: AgentActorContext<TodoState>;

  constructor(
    @IEventDispatcher dispatcher: IEventDispatcher,
    @IAgentScopeContext scopeContext: IAgentScopeContext,
    @IInstantiationService instantiation: IInstantiationService,
  ) {
    super(dispatcher, scopeContext, instantiation);
    this.actor = this.attachActor(todoActorLogic, {
      id: 'todo',
      durable: {
        events: [ToolsUpdateStore],
        undoable: true,
        transition: (_state, event) => {
          if (!(event instanceof ToolsUpdateStore) || event.key !== 'todo') return;
          return readTodoItems(event.value);
        },
        read: (snapshot) => (snapshot as TodoActorSnapshot).context.todos,
        commit: (actor, todos) => { actor.send({ type: 'todo.commit', todos }); },
      },
    });
    this.onDidChange = this.actor.onDidChange;
  }

  get(): readonly TodoItem[] {
    this.actor.send({ type: 'todo.used' });
    return this.actor.getState();
  }

  replace(todos: readonly TodoItem[]): Promise<void> {
    this.actor.send({ type: 'todo.used' });
    return this.actor.dispatch(new ToolsUpdateStore({
      agentId: this.actor.agent.agentId,
      key: 'todo',
      value: todos.map((todo) => ({ title: todo.title, status: todo.status })),
    }));
  }

  clear(): Promise<void> {
    this.actor.send({ type: 'todo.used' });
    return this.actor.dispatch(new ToolsUpdateStore({
      agentId: this.actor.agent.agentId,
      key: 'todo',
      value: [],
    }));
  }
}