import { Prisma } from '@prisma/client';
import { db } from '../../lib/prisma';
import { getTenantIdOrThrow } from '../../lib/tenantContext';
import { BadRequestError, ConflictError, NotFoundError } from '../../lib/errors';

/**
 * Energy meters (Sprint 3 interface, TEPL). Each room has a meter; a common
 * area may have its own. A building-management system (BMS) — or, until
 * TEPL's is connected, our simulator — pushes readings: cumulative units per
 * meter at a time. TEPL's own API will be mapped onto this same interface.
 * The consumption dashboard (Sprint 4) reads from here.
 */

export interface MeterInput {
  propertyId: string;
  roomId?: string | null;
  code: string;
  name: string;
  kind?: 'ROOM' | 'COMMON';
  multiplier?: number;
  isActive?: boolean;
}

export function listMeters(propertyId?: string) {
  return db.energyMeter.findMany({ where: propertyId ? { propertyId } : {}, orderBy: [{ kind: 'desc' }, { name: 'asc' }], take: 5000 });
}

export async function createMeter(input: MeterInput) {
  if (!(await db.property.findFirst({ where: { id: input.propertyId }, select: { id: true } }))) throw new NotFoundError('Property not found');
  if (input.roomId && !(await db.room.findFirst({ where: { id: input.roomId, propertyId: input.propertyId }, select: { id: true } }))) throw new NotFoundError('Room not found in that property');
  if (await db.energyMeter.findFirst({ where: { code: input.code }, select: { id: true } })) throw new ConflictError(`Meter ${input.code} already exists`);
  return db.energyMeter.create({ data: { ...input, tenantId: getTenantIdOrThrow() } });
}

export async function updateMeter(id: string, input: Partial<Omit<MeterInput, 'propertyId'>>) {
  const m = await db.energyMeter.findFirst({ where: { id } });
  if (!m) throw new NotFoundError('Meter not found');
  if (input.code && input.code !== m.code && (await db.energyMeter.findFirst({ where: { code: input.code }, select: { id: true } }))) throw new ConflictError(`Meter ${input.code} already exists`);
  if (input.roomId && !(await db.room.findFirst({ where: { id: input.roomId, propertyId: m.propertyId }, select: { id: true } }))) throw new NotFoundError('Room not found in that property');
  return db.energyMeter.update({ where: { id }, data: input });
}

/**
 * The meter-to-room list from a sheet: meter code, block (a property's name),
 * room number (blank for a common-area meter) and a name. A meter already
 * there is updated to the row; nothing is deleted.
 */
export async function importMeters(rows: { code: string; block?: string | null; room?: string | null; name?: string | null }[], fallbackPropertyId?: string) {
  const properties = await db.property.findMany({ select: { id: true, name: true } });
  const results: { row: number; status: 'created' | 'updated' | 'error'; message?: string; code: string }[] = [];
  for (const [i, r] of rows.entries()) {
    const row = i + 2;
    try {
      const property = r.block ? properties.find((p) => p.name.toLowerCase() === r.block!.toLowerCase()) : properties.find((p) => p.id === fallbackPropertyId) ?? properties[0];
      if (!property) throw new BadRequestError(`No property called “${r.block}”`);
      const room = r.room ? await db.room.findFirst({ where: { propertyId: property.id, archivedAt: null, number: { equals: r.room, mode: 'insensitive' } }, select: { id: true, number: true } }) : null;
      if (r.room && !room) throw new BadRequestError(`No room ${r.room} in ${property.name}`);
      const data = { propertyId: property.id, roomId: room?.id ?? null, kind: room ? 'ROOM' : 'COMMON', name: r.name || (room ? `Room ${room.number}` : r.code) };
      const existing = await db.energyMeter.findFirst({ where: { code: r.code }, select: { id: true } });
      if (existing) {
        await db.energyMeter.update({ where: { id: existing.id }, data });
        results.push({ row, status: 'updated', code: r.code });
      } else {
        await db.energyMeter.create({ data: { ...data, code: r.code, tenantId: getTenantIdOrThrow() } });
        results.push({ row, status: 'created', code: r.code });
      }
    } catch (e) {
      results.push({ row, status: 'error', code: r.code, message: e instanceof Error ? e.message : 'Could not import this meter' });
    }
  }
  return { created: results.filter((x) => x.status === 'created').length, updated: results.filter((x) => x.status === 'updated').length, failed: results.filter((x) => x.status === 'error').length, results };
}

/**
 * Readings from the BMS: cumulative units per meter. The same reading twice
 * is skipped (systems re-send); meters we do not know are counted and named
 * so the office can add them.
 */
export async function ingestReadings(readings: { meter: string; readAt: string; kwh: number }[], source: 'BMS' | 'MANUAL' | 'SIMULATOR' = 'BMS') {
  const codes = [...new Set(readings.map((r) => r.meter))];
  const meters = await db.energyMeter.findMany({ where: { code: { in: codes } }, select: { id: true, code: true } });
  const byCode = new Map(meters.map((m) => [m.code, m.id]));
  const tenantId = getTenantIdOrThrow();
  const data: Prisma.MeterReadingCreateManyInput[] = [];
  const unknown = new Set<string>();
  let invalid = 0;
  for (const r of readings) {
    const meterId = byCode.get(r.meter);
    const at = new Date(r.readAt);
    if (!meterId) {
      unknown.add(r.meter);
      continue;
    }
    if (Number.isNaN(at.getTime()) || !Number.isFinite(r.kwh) || r.kwh < 0) {
      invalid++;
      continue;
    }
    data.push({ tenantId, meterId, readAt: at, kwh: r.kwh, source });
  }
  const made = data.length ? await db.meterReading.createMany({ data, skipDuplicates: true }) : { count: 0 };
  return { received: readings.length, accepted: made.count, duplicates: data.length - made.count, invalid, unknownMeters: [...unknown].slice(0, 50) };
}

/** A meter's latest reading and when it came, for the setup screen. */
export async function lastReadings(propertyId?: string) {
  const meters = await listMeters(propertyId);
  const last = await db.meterReading.groupBy({ by: ['meterId'], where: { meterId: { in: meters.map((m) => m.id) } }, _max: { readAt: true } });
  const at = new Map(last.map((l) => [l.meterId, l._max.readAt]));
  return meters.map((m) => ({ ...m, lastReadAt: at.get(m.id) ?? null }));
}
