import { Request, Response } from 'express';
import ausruestungsanfrageService from '../services/ausruestungsanfrage.service';
import notificationService from '../services/notification.service';
import { permissionService } from '../services/permission.service';
import logger from '../utils/logger';

class AusruestungsanfrageController {
  // -------------------------------------------------------------------------
  // Categories (DB-backed)
  // -------------------------------------------------------------------------

  async getKategorien(_req: Request, res: Response): Promise<void> {
    try {
      const kategorien = await ausruestungsanfrageService.getKategorien();
      res.status(200).json({ success: true, data: kategorien });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getKategorien error', { error });
      res.status(500).json({ success: false, message: 'Kategorien konnten nicht geladen werden' });
    }
  }

  async createKategorie(req: Request, res: Response): Promise<void> {
    try {
      const { name, parent_id } = req.body;
      if (!name || name.trim().length === 0) {
        res.status(400).json({ success: false, message: 'Name ist erforderlich' });
        return;
      }
      const kategorie = await ausruestungsanfrageService.createKategorie(name.trim(), parent_id ?? null);
      res.status(201).json({ success: true, data: kategorie });
    } catch (error: any) {
      if (error?.constraint?.includes('unique') || error?.code === '23505') {
        res.status(409).json({ success: false, message: 'Kategorie existiert bereits' });
        return;
      }
      logger.error('AusruestungsanfrageController.createKategorie error', { error });
      res.status(500).json({ success: false, message: 'Kategorie konnte nicht erstellt werden' });
    }
  }

  async updateKategorie(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const { name, parent_id } = req.body;
      if (name !== undefined && (!name || name.trim().length === 0)) {
        res.status(400).json({ success: false, message: 'Name ist erforderlich' });
        return;
      }
      const kategorie = await ausruestungsanfrageService.updateKategorie(id, {
        name: name?.trim(),
        parent_id: parent_id !== undefined ? parent_id : undefined,
      });
      if (!kategorie) {
        res.status(404).json({ success: false, message: 'Kategorie nicht gefunden' });
        return;
      }
      res.status(200).json({ success: true, data: kategorie });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updateKategorie error', { error });
      res.status(500).json({ success: false, message: 'Kategorie konnte nicht aktualisiert werden' });
    }
  }

  async deleteKategorie(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      await ausruestungsanfrageService.deleteKategorie(id);
      res.status(200).json({ success: true, message: 'Kategorie gelöscht' });
    } catch (error) {
      logger.error('AusruestungsanfrageController.deleteKategorie error', { error });
      res.status(500).json({ success: false, message: 'Kategorie konnte nicht gelöscht werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Catalog Items
  // -------------------------------------------------------------------------

  async getItems(req: Request, res: Response): Promise<void> {
    try {
      const kategorie = req.query.kategorie as string | undefined;
      const kategorie_id = req.query.kategorie_id ? Number(req.query.kategorie_id) : undefined;
      const aktiv = req.query.aktiv !== undefined ? req.query.aktiv === 'true' : undefined;
      const search = req.query.search as string | undefined;
      const items = await ausruestungsanfrageService.getItems({ kategorie, kategorie_id, aktiv, search });
      res.status(200).json({ success: true, data: items });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getItems error', { error });
      res.status(500).json({ success: false, message: 'Artikel konnten nicht geladen werden' });
    }
  }

  async getItemById(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const item = await ausruestungsanfrageService.getItemById(id);
      if (!item) {
        res.status(404).json({ success: false, message: 'Artikel nicht gefunden' });
        return;
      }
      res.status(200).json({ success: true, data: item });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getItemById error', { error });
      res.status(500).json({ success: false, message: 'Artikel konnte nicht geladen werden' });
    }
  }

  async createItem(req: Request, res: Response): Promise<void> {
    try {
      const { bezeichnung } = req.body;
      if (!bezeichnung || bezeichnung.trim().length === 0) {
        res.status(400).json({ success: false, message: 'Bezeichnung ist erforderlich' });
        return;
      }
      const item = await ausruestungsanfrageService.createItem(req.body, req.user!.id);
      res.status(201).json({ success: true, data: item });
    } catch (error) {
      logger.error('AusruestungsanfrageController.createItem error', { error });
      res.status(500).json({ success: false, message: 'Artikel konnte nicht erstellt werden' });
    }
  }

  async updateItem(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const item = await ausruestungsanfrageService.updateItem(id, req.body, req.user!.id);
      if (!item) {
        res.status(404).json({ success: false, message: 'Artikel nicht gefunden' });
        return;
      }
      res.status(200).json({ success: true, data: item });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updateItem error', { error });
      res.status(500).json({ success: false, message: 'Artikel konnte nicht aktualisiert werden' });
    }
  }

  async deleteItem(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      await ausruestungsanfrageService.deleteItem(id);
      res.status(200).json({ success: true, message: 'Artikel gelöscht' });
    } catch (error) {
      logger.error('AusruestungsanfrageController.deleteItem error', { error });
      res.status(500).json({ success: false, message: 'Artikel konnte nicht gelöscht werden' });
    }
  }

  async getCategories(_req: Request, res: Response): Promise<void> {
    try {
      const categories = await ausruestungsanfrageService.getCategories();
      res.status(200).json({ success: true, data: categories });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getCategories error', { error });
      res.status(500).json({ success: false, message: 'Kategorien konnten nicht geladen werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Artikel Eigenschaften (characteristics)
  // -------------------------------------------------------------------------

  async getArtikelEigenschaften(req: Request, res: Response): Promise<void> {
    try {
      const artikelId = Number(req.params.id);
      const eigenschaften = await ausruestungsanfrageService.getArtikelEigenschaften(artikelId);
      res.status(200).json({ success: true, data: eigenschaften });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getArtikelEigenschaften error', { error });
      res.status(500).json({ success: false, message: 'Eigenschaften konnten nicht geladen werden' });
    }
  }

  async upsertArtikelEigenschaft(req: Request, res: Response): Promise<void> {
    try {
      const artikelId = Number(req.params.id);
      const { name, typ, optionen, pflicht, sort_order, eigenschaft_id } = req.body;
      if (!name || name.trim().length === 0) {
        res.status(400).json({ success: false, message: 'Name ist erforderlich' });
        return;
      }
      if (!typ || !['options', 'freitext'].includes(typ)) {
        res.status(400).json({ success: false, message: 'Typ muss "options" oder "freitext" sein' });
        return;
      }
      const eigenschaft = await ausruestungsanfrageService.upsertArtikelEigenschaft(artikelId, {
        id: eigenschaft_id,
        name: name.trim(),
        typ,
        optionen: optionen || undefined,
        pflicht: pflicht ?? false,
        sort_order: sort_order ?? 0,
      });
      res.status(eigenschaft_id ? 200 : 201).json({ success: true, data: eigenschaft });
    } catch (error) {
      logger.error('AusruestungsanfrageController.upsertArtikelEigenschaft error', { error });
      res.status(500).json({ success: false, message: 'Eigenschaft konnte nicht gespeichert werden' });
    }
  }

  async deleteArtikelEigenschaft(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.eigenschaftId);
      await ausruestungsanfrageService.deleteArtikelEigenschaft(id);
      res.status(200).json({ success: true, message: 'Eigenschaft gelöscht' });
    } catch (error) {
      logger.error('AusruestungsanfrageController.deleteArtikelEigenschaft error', { error });
      res.status(500).json({ success: false, message: 'Eigenschaft konnte nicht gelöscht werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Users (for "order on behalf of" autocomplete)
  // -------------------------------------------------------------------------

  async getAllUsers(_req: Request, res: Response): Promise<void> {
    try {
      const users = await ausruestungsanfrageService.getAllUsers();
      res.status(200).json({ success: true, data: users });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getAllUsers error', { error });
      res.status(500).json({ success: false, message: 'Benutzer konnten nicht geladen werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Requests
  // -------------------------------------------------------------------------

  async getRequests(req: Request, res: Response): Promise<void> {
    try {
      const status = req.query.status as string | undefined;
      const anfrager_id = req.query.anfrager_id as string | undefined;
      const requests = await ausruestungsanfrageService.getRequests({ status, anfrager_id });
      res.status(200).json({ success: true, data: requests });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getRequests error', { error });
      res.status(500).json({ success: false, message: 'Anfragen konnten nicht geladen werden' });
    }
  }

  async getMyRequests(req: Request, res: Response): Promise<void> {
    try {
      const requests = await ausruestungsanfrageService.getMyRequests(req.user!.id);
      res.status(200).json({ success: true, data: requests });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getMyRequests error', { error });
      res.status(500).json({ success: false, message: 'Anfragen konnten nicht geladen werden' });
    }
  }

  async getRequestById(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const request = await ausruestungsanfrageService.getRequestById(id);
      if (!request) {
        res.status(404).json({ success: false, message: 'Anfrage nicht gefunden' });
        return;
      }
      res.status(200).json({ success: true, data: request });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getRequestById error', { error });
      res.status(500).json({ success: false, message: 'Anfrage konnte nicht geladen werden' });
    }
  }

  async createRequest(req: Request, res: Response): Promise<void> {
    try {
      const { items, notizen, bezeichnung, fuer_benutzer_id, fuer_benutzer_name } = req.body as {
        items?: { artikel_id?: number; bezeichnung: string; menge: number; notizen?: string; eigenschaften?: { eigenschaft_id: number; wert: string }[]; persoenlich_id?: string; neuer_zustand?: string }[];
        notizen?: string;
        bezeichnung?: string;
        fuer_benutzer_id?: string;
        fuer_benutzer_name?: string;
      };

      if (!items || items.length === 0) {
        res.status(400).json({ success: false, message: 'Mindestens eine Position ist erforderlich' });
        return;
      }

      for (const item of items) {
        if (!item.persoenlich_id && (!item.bezeichnung || item.bezeichnung.trim().length === 0)) {
          res.status(400).json({ success: false, message: 'Bezeichnung ist für alle Positionen erforderlich' });
          return;
        }
        if (!item.menge || item.menge < 1) {
          res.status(400).json({ success: false, message: 'Menge muss mindestens 1 sein' });
          return;
        }
      }

      // Determine anfrager: self or on behalf of another user
      let anfragerId = req.user!.id;
      let storedFuerBenutzerName: string | undefined;
      if (fuer_benutzer_id && fuer_benutzer_id !== req.user!.id) {
        const groups = req.user?.groups ?? [];
        const canOrderForUser = groups.includes('dashboard_admin') || permissionService.hasPermission(groups, 'ausruestungsanfrage:order_for_user');
        if (!canOrderForUser) {
          res.status(403).json({ success: false, message: 'Keine Berechtigung für Bestellung im Auftrag' });
          return;
        }
        anfragerId = fuer_benutzer_id;
      } else if (fuer_benutzer_name && !fuer_benutzer_id) {
        // Custom name for user not in system — keep anfrager_id as current user
        const groups = req.user?.groups ?? [];
        const canOrderForUser = groups.includes('dashboard_admin') || permissionService.hasPermission(groups, 'ausruestungsanfrage:order_for_user');
        if (!canOrderForUser) {
          res.status(403).json({ success: false, message: 'Keine Berechtigung für Bestellung im Auftrag' });
          return;
        }
        storedFuerBenutzerName = fuer_benutzer_name;
      }

      const request = await ausruestungsanfrageService.createRequest(anfragerId, items, notizen, bezeichnung, storedFuerBenutzerName);
      res.status(201).json({ success: true, data: request });
    } catch (error) {
      logger.error('AusruestungsanfrageController.createRequest error', { error });
      res.status(500).json({ success: false, message: 'Anfrage konnte nicht erstellt werden' });
    }
  }

  async updateRequest(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const { bezeichnung, notizen, items } = req.body as {
        bezeichnung?: string;
        notizen?: string;
        items?: { artikel_id?: number; bezeichnung: string; menge: number; notizen?: string; eigenschaften?: { eigenschaft_id: number; wert: string }[] }[];
      };

      // Validate items if provided
      if (items) {
        if (items.length === 0) {
          res.status(400).json({ success: false, message: 'Mindestens eine Position ist erforderlich' });
          return;
        }
        for (const item of items) {
          if (!item.bezeichnung || item.bezeichnung.trim().length === 0) {
            res.status(400).json({ success: false, message: 'Bezeichnung ist für alle Positionen erforderlich' });
            return;
          }
          if (!item.menge || item.menge < 1) {
            res.status(400).json({ success: false, message: 'Menge muss mindestens 1 sein' });
            return;
          }
        }
      }

      const existing = await ausruestungsanfrageService.getRequestById(id);
      if (!existing) {
        res.status(404).json({ success: false, message: 'Anfrage nicht gefunden' });
        return;
      }

      // Check permission: owner + status=offen, OR ausruestungsanfrage:edit
      const groups = req.user?.groups ?? [];
      const canEditAny = groups.includes('dashboard_admin') || permissionService.hasPermission(groups, 'ausruestungsanfrage:edit');
      const isOwner = existing.anfrage.anfrager_id === req.user!.id;
      if (!canEditAny && !(isOwner && existing.anfrage.status === 'offen')) {
        res.status(403).json({ success: false, message: 'Keine Berechtigung zum Bearbeiten dieser Anfrage' });
        return;
      }

      const updated = await ausruestungsanfrageService.updateRequest(id, { bezeichnung, notizen, items });
      res.status(200).json({ success: true, data: updated });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updateRequest error', { error });
      res.status(500).json({ success: false, message: 'Anfrage konnte nicht aktualisiert werden' });
    }
  }

  async updateRequestStatus(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const { status, admin_notizen } = req.body as {
        status?: string;
        admin_notizen?: string;
      };

      if (!status) {
        res.status(400).json({ success: false, message: 'Status ist erforderlich' });
        return;
      }

      const validStatuses = ['offen', 'genehmigt', 'abgelehnt', 'bestellt', 'erledigt'];
      if (!validStatuses.includes(status)) {
        res.status(400).json({ success: false, message: `Ungültiger Status. Erlaubt: ${validStatuses.join(', ')}` });
        return;
      }

      // Fetch request to get anfrager_id for notification
      const existing = await ausruestungsanfrageService.getRequestById(id);
      if (!existing) {
        res.status(404).json({ success: false, message: 'Anfrage nicht gefunden' });
        return;
      }

      const updated = await ausruestungsanfrageService.updateRequestStatus(id, status, admin_notizen, req.user!.id);

      // Notify requester on status changes
      if (['genehmigt', 'abgelehnt', 'bestellt', 'erledigt'].includes(status)) {
        const orderLabel = existing.anfrage.bestell_jahr && existing.anfrage.bestell_nummer
          ? `${existing.anfrage.bestell_jahr}/${String(existing.anfrage.bestell_nummer).padStart(3, '0')}`
          : `#${id}`;
        await notificationService.createNotification({
          user_id: existing.anfrage.anfrager_id,
          typ: 'ausruestung_anfrage',
          titel: status === 'genehmigt' ? 'Anfrage genehmigt' : status === 'abgelehnt' ? 'Anfrage abgelehnt' : `Anfrage ${status}`,
          nachricht: `Deine Ausrüstungsanfrage ${orderLabel} wurde ${status === 'genehmigt' ? 'genehmigt' : status === 'abgelehnt' ? 'abgelehnt' : status}.`,
          schwere: status === 'abgelehnt' ? 'warnung' : 'info',
          link: '/ausruestungsanfrage',
          quell_id: String(id),
          quell_typ: 'ausruestung_anfrage',
        });
      }

      res.status(200).json({ success: true, data: updated });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updateRequestStatus error', { error });
      res.status(500).json({ success: false, message: 'Status konnte nicht aktualisiert werden' });
    }
  }

  async deleteRequest(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      await ausruestungsanfrageService.deleteRequest(id);
      res.status(200).json({ success: true, message: 'Anfrage gelöscht' });
    } catch (error) {
      logger.error('AusruestungsanfrageController.deleteRequest error', { error });
      res.status(500).json({ success: false, message: 'Anfrage konnte nicht gelöscht werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Position delivery tracking
  // -------------------------------------------------------------------------

  async updatePositionGeliefert(req: Request, res: Response): Promise<void> {
    try {
      const positionId = Number(req.params.positionId);
      const { geliefert } = req.body as { geliefert?: boolean };

      if (typeof geliefert !== 'boolean') {
        res.status(400).json({ success: false, message: 'geliefert (boolean) ist erforderlich' });
        return;
      }

      const position = await ausruestungsanfrageService.updatePositionGeliefert(positionId, geliefert);
      if (!position) {
        res.status(404).json({ success: false, message: 'Position nicht gefunden' });
        return;
      }

      res.status(200).json({ success: true, data: position });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updatePositionGeliefert error', { error });
      res.status(500).json({ success: false, message: 'Lieferstatus konnte nicht aktualisiert werden' });
    }
  }

  async updatePositionZurueckgegeben(req: Request, res: Response): Promise<void> {
    try {
      const positionId = Number(req.params.positionId);
      const { altes_geraet_zurueckgegeben } = req.body as { altes_geraet_zurueckgegeben?: boolean };

      if (typeof altes_geraet_zurueckgegeben !== 'boolean') {
        res.status(400).json({ success: false, message: 'altes_geraet_zurueckgegeben (boolean) ist erforderlich' });
        return;
      }

      const position = await ausruestungsanfrageService.updatePositionZurueckgegeben(positionId, altes_geraet_zurueckgegeben);
      if (!position) {
        res.status(404).json({ success: false, message: 'Position nicht gefunden' });
        return;
      }

      res.status(200).json({ success: true, data: position });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updatePositionZurueckgegeben error', { error });
      res.status(500).json({ success: false, message: 'Rückgabestatus konnte nicht aktualisiert werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Overview
  // -------------------------------------------------------------------------

  async getOverview(_req: Request, res: Response): Promise<void> {
    try {
      const overview = await ausruestungsanfrageService.getOverview();
      res.status(200).json({ success: true, data: overview });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getOverview error', { error });
      res.status(500).json({ success: false, message: 'Übersicht konnte nicht geladen werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Linking
  // -------------------------------------------------------------------------

  async linkToOrder(req: Request, res: Response): Promise<void> {
    try {
      const anfrageId = Number(req.params.id);
      const { bestellung_id } = req.body as { bestellung_id?: number };

      if (!bestellung_id) {
        res.status(400).json({ success: false, message: 'bestellung_id ist erforderlich' });
        return;
      }

      await ausruestungsanfrageService.linkToOrder(anfrageId, bestellung_id);
      res.status(200).json({ success: true, message: 'Verknüpfung erstellt' });
    } catch (error) {
      logger.error('AusruestungsanfrageController.linkToOrder error', { error });
      res.status(500).json({ success: false, message: 'Verknüpfung konnte nicht erstellt werden' });
    }
  }

  async unlinkFromOrder(req: Request, res: Response): Promise<void> {
    try {
      const anfrageId = Number(req.params.id);
      const bestellungId = Number(req.params.bestellungId);
      await ausruestungsanfrageService.unlinkFromOrder(anfrageId, bestellungId);
      res.status(200).json({ success: true, message: 'Verknüpfung entfernt' });
    } catch (error) {
      logger.error('AusruestungsanfrageController.unlinkFromOrder error', { error });
      res.status(500).json({ success: false, message: 'Verknüpfung konnte nicht entfernt werden' });
    }
  }

  async createOrders(req: Request, res: Response): Promise<void> {
    try {
      const anfrageId = Number(req.params.id);
      const { orders } = req.body as {
        orders: Array<{
          lieferant_id: number;
          bezeichnung: string;
          positionen: Array<{ position_id: number; bezeichnung: string; menge: number; einheit?: string; notizen?: string }>;
        }>;
      };

      if (!orders || orders.length === 0) {
        res.status(400).json({ success: false, message: 'Mindestens eine Bestellung ist erforderlich' });
        return;
      }

      const created = await ausruestungsanfrageService.createOrdersFromRequest(anfrageId, orders, req.user!.id);
      res.status(201).json({ success: true, data: { created_bestellungen: created } });
    } catch (error) {
      logger.error('AusruestungsanfrageController.createOrders error', { error });
      res.status(500).json({ success: false, message: 'Bestellungen konnten nicht erstellt werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Assignment of delivered items
  // -------------------------------------------------------------------------

  async assignDeliveredItems(req: Request, res: Response): Promise<void> {
    try {
      const id = Number(req.params.id);
      const { assignments } = req.body as {
        assignments?: Array<{
          positionId: number;
          typ: 'ausruestung' | 'persoenlich' | 'keine';
          fahrzeugId?: string;
          standort?: string;
          userId?: string;
          benutzerName?: string;
          groesse?: string;
          kategorie?: string;
          eigenschaften?: Array<{ eigenschaft_id?: number; name: string; wert: string }>;
        }>;
      };

      if (!assignments || assignments.length === 0) {
        res.status(400).json({ success: false, message: 'Mindestens eine Zuweisung ist erforderlich' });
        return;
      }

      for (const a of assignments) {
        if (!a.positionId || !a.typ) {
          res.status(400).json({ success: false, message: 'positionId und typ sind erforderlich' });
          return;
        }
        if (!['ausruestung', 'persoenlich', 'keine'].includes(a.typ)) {
          res.status(400).json({ success: false, message: 'Ungültiger Zuweisungstyp' });
          return;
        }
      }

      const result = await ausruestungsanfrageService.assignDeliveredItems(id, req.user!.id, assignments);
      res.status(200).json({ success: true, data: result });
    } catch (error: any) {
      if (error?.message === 'Anfrage nicht gefunden') {
        res.status(404).json({ success: false, message: error.message });
        return;
      }
      logger.error('AusruestungsanfrageController.assignDeliveredItems error', { error });
      res.status(500).json({ success: false, message: 'Zuweisung konnte nicht gespeichert werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Widget overview (lightweight, for dashboard widget)
  // -------------------------------------------------------------------------

  async getWidgetOverview(_req: Request, res: Response): Promise<void> {
    try {
      const overview = await ausruestungsanfrageService.getWidgetOverview();
      res.status(200).json({ success: true, data: overview });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getWidgetOverview error', { error });
      res.status(500).json({ success: false, message: 'Widget-Daten konnten nicht geladen werden' });
    }
  }

  // -------------------------------------------------------------------------
  // Unassigned positions
  // -------------------------------------------------------------------------

  async getUnassignedPositions(_req: Request, res: Response): Promise<void> {
    try {
      const data = await ausruestungsanfrageService.getUnassignedPositions();
      res.status(200).json({ success: true, data });
    } catch (error) {
      logger.error('AusruestungsanfrageController.getUnassignedPositions error', { error });
      res.status(500).json({ success: false, message: 'Fehler beim Laden' });
    }
  }

  async updatePositionArtikelId(req: Request, res: Response): Promise<void> {
    try {
      const positionId = Number(req.params.positionId);
      const artikelId = Number(req.body.artikel_id);
      if (isNaN(positionId) || isNaN(artikelId) || artikelId <= 0) {
        res.status(400).json({ success: false, message: 'Ungültige IDs' });
        return;
      }
      const updated = await ausruestungsanfrageService.updatePositionArtikelId(positionId, artikelId);
      if (!updated) {
        res.status(404).json({ success: false, message: 'Position nicht gefunden' });
        return;
      }
      res.status(200).json({ success: true, data: updated });
    } catch (error) {
      logger.error('AusruestungsanfrageController.updatePositionArtikelId error', { error });
      res.status(500).json({ success: false, message: 'Fehler beim Aktualisieren' });
    }
  }
}

export default new AusruestungsanfrageController();
