import { Response } from 'express';
import { supabase } from '../lib/supabase';
import { AuthenticatedRequest } from '../middleware/auth';
import { extractTextFromUploadedFile, sanitizePostgresText } from './document.controller';

// Belge Şablonları: avukatın büro genelinde kullandığı dilekçe/evrak şablonları.
// Ayrı bir Storage bucket açmaya gerek kalmasın diye documents'ın kullandığı
// "case-documents" bucket'ı "templates/" öneki altında paylaşılıyor.
//
// Metni de çıkarıyoruz (documents'taki gibi) — Dilekçe Hazırlama'da bir şablon
// seçildiğinde AI'nin bu metni büronun kendi dili/formatı için referans alması
// gerekiyor (bkz. drafting.controller.ts).
export const uploadTemplate = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const file = req.file;
    const userId = req.user?.id;
    const { category, name, description } = req.body || {};

    if (!file || !userId || !name) {
      return res.status(400).json({ error: 'file ve name zorunludur.' });
    }

    let extractedText: string | null = null;
    try {
      extractedText = await extractTextFromUploadedFile(file);
    } catch (err) {
      // Metin çıkarımı başarısız olsa da şablon yine de yüklenip indirilebilir olsun —
      // sadece AI stil referansı olarak kullanılamayacak.
      console.error('Template Text Extraction Error:', err);
    }

    const sanitizeFilename = (name: string) => {
      const charMap: Record<string, string> = { 'ç': 'c', 'ğ': 'g', 'ı': 'i', 'ö': 'o', 'ş': 's', 'ü': 'u', 'Ç': 'C', 'Ğ': 'G', 'İ': 'I', 'Ö': 'O', 'Ş': 'S', 'Ü': 'U' };
      const engName = name.replace(/[çğıöşüÇĞİÖŞÜ]/g, m => charMap[m]);
      return engName.replace(/[^a-zA-Z0-9.\-_]/g, '_');
    };
    
    const safeName = sanitizeFilename(file.originalname);
    const storagePath = `templates/${userId}/${Date.now()}_${safeName}`;
    const { error: uploadError } = await supabase.storage
      .from('case-documents')
      .upload(storagePath, file.buffer, { contentType: file.mimetype });
    if (uploadError) {
      console.error('Template Storage Upload Error:', uploadError);
      return res.status(500).json({ error: 'Şablon dosyası yüklenemedi.' });
    }

    const cleanName = sanitizePostgresText(String(name)).slice(0, 200);
    const cleanCategory = category ? sanitizePostgresText(String(category)) : null;
    const cleanDescription = description ? sanitizePostgresText(String(description)) : null;
    const cleanText = extractedText ? sanitizePostgresText(extractedText) : null;

    let { data, error } = await supabase
      .from('templates')
      .insert([{
        user_id: userId,
        category: cleanCategory,
        name: cleanName,
        description: cleanDescription,
        storage_path: storagePath,
        file_size: file.size,
        mime_type: file.mimetype || 'application/octet-stream',
        extracted_text: cleanText,
      }])
      .select()
      .single();

    if (error) {
      console.warn('Template insert initial attempt error, retrying with null text:', error.message);
      const retry = await supabase
        .from('templates')
        .insert([{
          user_id: userId,
          category: cleanCategory,
          name: cleanName,
          description: cleanDescription,
          storage_path: storagePath,
          file_size: file.size,
          mime_type: file.mimetype || 'application/octet-stream',
          extracted_text: null,
        }])
        .select()
        .single();
      if (retry.error) throw retry.error;
      data = retry.data;
    }

    res.json({ template: data });
  } catch (error: any) {
    console.error('Upload Template Error:', error);
    res.status(500).json({ error: error.message || 'Internal Server Error' });
  }
};

// İndirme için kısa ömürlü bir imzalı URL üretir — bucket public değil.
export const getTemplateDownloadUrl = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const { templateId } = req.params;
    const userId = req.user?.id;
    const { data: template, error: fetchError } = await supabase
      .from('templates')
      .select('storage_path, user_id')
      .eq('id', templateId)
      .single();
    if (fetchError || !template) {
      return res.status(404).json({ error: 'Şablon bulunamadı.' });
    }
    if (template.user_id !== userId) {
      return res.status(403).json({ error: 'Bu şablona erişim yetkiniz yok.' });
    }

    const { data, error } = await supabase.storage
      .from('case-documents')
      .createSignedUrl(template.storage_path, 60);
    if (error || !data) throw error || new Error('İmzalı URL üretilemedi.');

    res.json({ url: data.signedUrl });
  } catch (error: any) {
    console.error('Get Template Download URL Error:', error);
    res.status(500).json({ error: error.message || 'Internal Server Error' });
  }
};

export const deleteTemplate = async (req: AuthenticatedRequest, res: Response) => {
  try {
    const { templateId } = req.params;
    const userId = req.user?.id;
    const { data: template, error: fetchError } = await supabase
      .from('templates')
      .select('storage_path, user_id')
      .eq('id', templateId)
      .single();
    if (fetchError || !template) {
      return res.status(404).json({ error: 'Şablon bulunamadı.' });
    }
    if (template.user_id !== userId) {
      return res.status(403).json({ error: 'Bu şablonu silme yetkiniz yok.' });
    }

    await supabase.storage.from('case-documents').remove([template.storage_path]);
    const { error } = await supabase.from('templates').delete().eq('id', templateId);
    if (error) throw error;

    res.json({ ok: true });
  } catch (error: any) {
    console.error('Delete Template Error:', error);
    res.status(500).json({ error: error.message || 'Internal Server Error' });
  }
};
