import { GoogleGenAI, Type } from "@google/genai";
import { StorageRecord, Customer } from "../types";

const getAiInstance = () => new GoogleGenAI({ apiKey: process.env.API_KEY });

export const generateAssistantResponse = async (
  query: string,
  contextData: { records: StorageRecord[]; customers: Customer[] }
): Promise<string> => {
  const ai = getAiInstance();

  const contextString = `
    Aktueller Datenbestand:
    ${contextData.records.length} Reifensätze eingelagert.
    Lagerliste (Auszug):
    ${contextData.records.slice(0, 10).map(r => 
      `- Kunde: ${r.customerId}, KZ: ${r.licensePlate}, Auto: ${r.vehicleManufacturer} ${r.vehicleModel}, Typ: ${r.season}, Status: ${r.status}, Ort: ${r.location}`
    ).join('\n')}
  `;

  try {
    // Fix: Using any to bypass TS2411 error in library definition for GenerateContentResponse
    const response: any = await ai.models.generateContent({
      model: 'gemini-3-pro-preview',
      contents: `
        Du bist der intelligente Assistent für ein Radeinlagerungs-System.
        Nutze die folgenden Kontextdaten, um die Anfrage des Nutzers zu beantworten.
        Antworte höflich und auf Deutsch.
        
        KONTEXT DATEN:
        ${contextString}
        
        NUTZER ANFRAGE:
        ${query}
      `,
    });
    return response.text || "Ich konnte keine Antwort generieren.";
  } catch (error) {
    console.error("Gemini Error:", error);
    return "Fehler bei der Kommunikation mit der KI.";
  }
};

/**
 * Extrahiert umfassende Daten aus einem Foto oder PDF eines Einlagerungsscheins
 */
export interface ExtractedDocumentData {
  location: string;
  licensePlate: string;
  vehicleManufacturer: string;
  vehicleModel: string;
  tireManufacturer: string;
  tireDimension: string;
  dot: string;
  treadDepth: {
    vl: number;
    vr: number;
    hl: number;
    hr: number;
  };
  customerName: string;
  confidence: number; // Overall confidence
  fieldConfidence?: {
      location: number;
      licensePlate: number;
      vehicle: number;
      tires: number;
  };
}

export const extractLocationFromImage = async (base64Data: string, mimeType: string): Promise<ExtractedDocumentData> => {
  const ai = getAiInstance();
  const cleanBase64 = base64Data.includes(',') ? base64Data.split(',')[1] : base64Data;
  const supportedMimeTypes = ['image/png', 'image/jpeg', 'image/webp', 'image/heic', 'image/heif', 'application/pdf'];
  const finalMimeType = supportedMimeTypes.includes(mimeType) ? mimeType : 'image/jpeg';

  try {
    // Fix: Using any to bypass TS2411 error in library definition for GenerateContentResponse
    const response: any = await ai.models.generateContent({
      model: 'gemini-3-flash-preview', 
      contents: {
        parts: [
          { inlineData: { data: cleanBase64, mimeType: finalMimeType } },
          {
            text: `Analysiere dieses Dokument (Einlagerungsschein). Extrahiere Daten und gib für jedes Feld einen "confidence" Wert (0.0 bis 1.0) an, wie sicher du dir bist.
            
            Struktur:
            - location: Lagerort (z.B. 042, REG-10)
            - licensePlate: Kennzeichen
            - vehicleManufacturer: Hersteller
            - vehicleModel: Modell
            - tireManufacturer: Reifenmarke
            - tireDimension: Dimension
            - dot: DOT Nummer
            - treadDepth: Profiltiefen Objekt (vl, vr, hl, hr)
            - customerName: Kunde
            - fieldConfidence: Objekt mit confidence scores für 'location', 'licensePlate', 'vehicle', 'tires'
            
            Gib die Antwort STRENG im JSON-Format zurück.`
          }
        ]
      },
      config: {
        responseMimeType: "application/json",
        responseSchema: {
          type: Type.OBJECT,
          properties: {
            location: { type: Type.STRING },
            licensePlate: { type: Type.STRING },
            vehicleManufacturer: { type: Type.STRING },
            vehicleModel: { type: Type.STRING },
            tireManufacturer: { type: Type.STRING },
            tireDimension: { type: Type.STRING },
            dot: { type: Type.STRING },
            treadDepth: {
              type: Type.OBJECT,
              properties: {
                vl: { type: Type.NUMBER },
                vr: { type: Type.NUMBER },
                hl: { type: Type.NUMBER },
                hr: { type: Type.NUMBER }
              },
              required: ["vl", "vr", "hl", "hr"]
            },
            customerName: { type: Type.STRING },
            confidence: { type: Type.NUMBER },
            fieldConfidence: {
                type: Type.OBJECT,
                properties: {
                    location: { type: Type.NUMBER },
                    licensePlate: { type: Type.NUMBER },
                    vehicle: { type: Type.NUMBER },
                    tires: { type: Type.NUMBER }
                }
            }
          },
          required: ["location", "licensePlate", "confidence"],
        }
      }
    });

    const text = response.text;
    if (!text) throw new Error("KI hat kein Ergebnis geliefert.");
    
    return JSON.parse(text) as ExtractedDocumentData;
  } catch (error) {
    console.error("Vision Analysis Error:", error);
    throw new Error("Das Dokument konnte nicht analysiert werden.");
  }
};

export interface DeliveryNotePosition {
  articleNumber: string;
  name: string;
  quantity: number;
  price: number;
}

export interface DeliveryNoteData {
  supplier: string;
  deliveryNoteNumber: string;
  invoiceNumber: string;
  poNumber: string;
  date: string;
  positions: DeliveryNotePosition[];
  confidenceScores?: Record<string, number>; 
}

export const extractDeliveryNote = async (base64Data: string, mimeType: string): Promise<DeliveryNoteData> => {
  const ai = getAiInstance();
  const cleanBase64 = base64Data.includes(',') ? base64Data.split(',')[1] : base64Data;
  const supportedMimeTypes = ['image/png', 'image/jpeg', 'image/webp', 'image/heic', 'image/heif', 'application/pdf'];
  const finalMimeType = supportedMimeTypes.includes(mimeType) ? mimeType : 'image/jpeg';

  try {
    // Fix: Using any to bypass TS2411 error in library definition for GenerateContentResponse
    const response: any = await ai.models.generateContent({
      model: 'gemini-3-flash-preview',
      contents: {
        parts: [
          { inlineData: { data: cleanBase64, mimeType: finalMimeType } },
          {
            text: `Analysiere diesen Lieferschein oder diese Rechnung. 
            Extrahiere die Kopfdaten und ALLE gelisteten Artikelpositionen.
            
            Suche in der Tabelle nach:
            - Art-Nr / Artikelnummer
            - Bezeichnung / Artikelname
            - Menge / Anzahl
            - Einzelpreis / Preis
            
            Gib die Antwort STRENG im JSON-Format zurück.`
          }
        ]
      },
      config: {
        responseMimeType: "application/json",
        responseSchema: {
          type: Type.OBJECT,
          properties: {
            data: {
                type: Type.OBJECT,
                properties: {
                    supplier: { type: Type.STRING },
                    deliveryNoteNumber: { type: Type.STRING },
                    invoiceNumber: { type: Type.STRING },
                    poNumber: { type: Type.STRING },
                    date: { type: Type.STRING },
                    positions: {
                        type: Type.ARRAY,
                        items: {
                            type: Type.OBJECT,
                            properties: {
                                articleNumber: { type: Type.STRING },
                                name: { type: Type.STRING },
                                quantity: { type: Type.NUMBER },
                                price: { type: Type.NUMBER }
                            },
                            required: ["name", "quantity"]
                        }
                    }
                }
            },
            confidence: {
                type: Type.OBJECT,
                properties: {
                    supplier: { type: Type.NUMBER },
                    deliveryNoteNumber: { type: Type.NUMBER },
                    invoiceNumber: { type: Type.NUMBER },
                    poNumber: { type: Type.NUMBER },
                    date: { type: Type.NUMBER }
                }
            }
          }
        }
      }
    });

    const text = response.text;
    if (!text) throw new Error("KI hat kein Ergebnis geliefert.");
    
    const parsed = JSON.parse(text);
    
    return {
        supplier: parsed.data?.supplier || '',
        deliveryNoteNumber: parsed.data?.deliveryNoteNumber || '',
        invoiceNumber: parsed.data?.invoiceNumber || '',
        poNumber: parsed.data?.poNumber || '',
        date: parsed.data?.date || '',
        positions: parsed.data?.positions || [],
        confidenceScores: parsed.confidence || {}
    };
  } catch (error) {
    console.error("Delivery Note Analysis Error:", error);
    throw new Error("Fehler bei der Lieferschein-Analyse.");
  }
};