import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import {
  AlertIntegrationConfig,
  AlertIntegrationsRepository,
  AlertTrace,
} from '@task-stream/api/tracker/application';
import { Model } from 'mongoose';
import { ReadModels } from './read-model.schemas';

type Stored<T> = T & { _id?: unknown };

@Injectable()
export class MongoAlertIntegrationsRepository extends AlertIntegrationsRepository {
  constructor(
    @InjectModel(ReadModels.AlertIntegration)
    private readonly configs: Model<Stored<AlertIntegrationConfig>>,
    @InjectModel(ReadModels.AlertTrace)
    private readonly traces: Model<Stored<AlertTrace>>,
  ) {
    super();
  }

  async find(projectId: string): Promise<AlertIntegrationConfig | null> {
    const doc = await this.configs
      .findOne({ projectId })
      .lean<Stored<AlertIntegrationConfig>>();
    if (!doc) return null;
    const { _id: _ignored, ...config } = doc;
    return config;
  }

  async save(config: AlertIntegrationConfig): Promise<void> {
    await this.configs.updateOne(
      { projectId: config.projectId },
      { $set: config },
      { upsert: true },
    );
  }

  async remove(projectId: string): Promise<void> {
    // The traces stay: turned on again, repeats still find their bug.
    await this.configs.deleteOne({ projectId });
  }

  async trace(
    projectId: string,
    fingerprint: string,
  ): Promise<AlertTrace | null> {
    const doc = await this.traces
      .findOne({ projectId, fingerprint })
      .lean<Stored<AlertTrace>>();
    if (!doc) return null;
    const { _id: _ignored, ...trace } = doc;
    return trace;
  }

  async saveTrace(trace: AlertTrace): Promise<void> {
    await this.traces.updateOne(
      { projectId: trace.projectId, fingerprint: trace.fingerprint },
      { $set: trace },
      { upsert: true },
    );
  }
}