import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';

// Importlar (Yolları kendi proje yapına göre düzenle)
import '../features/dashboard/dashboard_page.dart';
import '../features/auth/screens/login_screen.dart'; // Login sayfanın yolu
import '../layout/admin_layout.dart';
import '../provider/auth_provider.dart'; // AuthProvider yolu

class AppRouter {
  // Router artık bir değişken değil, Provider alan bir metot
  static GoRouter createRouter(AuthProvider authProvider) {
    return GoRouter(
      initialLocation: '/dashboard',
      debugLogDiagnostics: true, // Debug konsolunda yönlendirmeleri görmek için
      
      // 1. ÖNEMLİ: AuthProvider'ı dinle (login/logout olduğunda router tetiklenir)
      refreshListenable: authProvider,

      // 2. ÖNEMLİ: Yönlendirme Mantığı (Guard)
      redirect: (BuildContext context, GoRouterState state) {
        final bool isLoggedIn = authProvider.isAuthenticated;
        final bool isLoggingIn = state.uri.toString() == '/login';

        // Kullanıcı giriş yapmamışsa ve login sayfasında değilse -> Login'e at
        if (!isLoggedIn && !isLoggingIn) {
          return '/login';
        }

        // Kullanıcı giriş yapmışsa ve login sayfasındaysa -> Dashboard'a at
        if (isLoggedIn && isLoggingIn) {
          return '/dashboard';
        }

        // Diğer durumlarda olduğu yerde kalsın
        return null;
      },

      routes: <RouteBase>[
        // ------------------------------------------------------------------
        // A. PUBLIC ROUTE (Layout YOK - Tam Ekran)
        // ------------------------------------------------------------------
        GoRoute(
          path: '/login',
          builder: (BuildContext context, GoRouterState state) {
            return const LoginScreen(); // Login sayfan
          },
        ),

        // ------------------------------------------------------------------
        // B. PROTECTED ROUTES (AdminLayout İÇİNDE - Sidebar Var)
        // ------------------------------------------------------------------
        ShellRoute(
          builder: (BuildContext context, GoRouterState state, Widget child) {
            return AdminLayout(child: child); // Senin mevcut layout yapın
          },
          routes: <RouteBase>[
            GoRoute(
              path: '/dashboard',
              builder: (BuildContext context, GoRouterState state) {
                return DashboardPage(); // Senin mevcut dashboard sayfan
              },
            ),
            GoRoute(
              path: '/users',
              builder: (BuildContext context, GoRouterState state) {
                return const Center(child: Text("Users"));
              },
            ),
            GoRoute(
              path: '/settings',
              builder: (BuildContext context, GoRouterState state) {
                return const Center(child: Text("Settings"));
              },
            ),
          ],
        ),
      ],
    );
  }
}

// lib/providers/auth_provider.dart

import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter/material.dart';

class AuthProvider extends ChangeNotifier {
  // Başlangıç durumu: Firebase'de kullanıcı var mı?
  bool _isAuthenticated = FirebaseAuth.instance.currentUser != null;
  bool get isAuthenticated => _isAuthenticated;

  AuthProvider() {
    _init();
  }

  void _init() {
    // Firebase Auth durumunu dinle
    // (Böylece main.dart'taki otomatik giriş veya logout anında algılanır)
    FirebaseAuth.instance.authStateChanges().listen((User? user) {
      final bool isLoggedIn = user != null;
      
      // Sadece durum değiştiyse güncelle
      if (_isAuthenticated != isLoggedIn) {
        _isAuthenticated = isLoggedIn;
        notifyListeners(); // Router'ı tetikler!
      }
    });
  }

  // Manuel Login (Login Ekranı için)
  Future<void> login(String email, String password) async {
    await FirebaseAuth.instance.signInWithEmailAndPassword(
      email: email, 
      password: password
    );
    // authStateChanges() zaten dinlediği için burada notifyListeners() çağırmaya gerek yok,
    // ama manuel akış kontrolü için beklenebilir.
  }

  // Şifre sıfırlama e-postası gönder
  Future<void> sendPasswordResetEmail(String email) async {
    await FirebaseAuth.instance.sendPasswordResetEmail(email: email);
  }

  // Logout
  Future<void> logout() async {
    await FirebaseAuth.instance.signOut();
    // authStateChanges() dinlediği için otomatik false olur ve login'e atar.
  }
}

import 'package:crm_maa/providers/auth_provider.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart'; // Autofill için gerekli
import 'package:provider/provider.dart';


class LoginPage extends StatefulWidget {
  const LoginPage({super.key});

  @override
  State<LoginPage> createState() => _LoginPageState();
}

class _LoginPageState extends State<LoginPage> {
  final _formKey = GlobalKey<FormState>();
  final _emailController = TextEditingController();
  final _passwordController = TextEditingController();

  bool _isLoading = false;
  bool _isPasswordVisible = false; // Şifre görünürlük durumu

  @override
  void dispose() {
    _emailController.dispose();
    _passwordController.dispose();
    super.dispose();
  }

  Future<void> _handleLogin() async {
    if (_formKey.currentState!.validate()) {
      // Klavye/Autofill servisine formun bittiğini bildirir (Şifreyi kaydet önerisi çıkarır)
      TextInput.finishAutofillContext();

      setState(() => _isLoading = true);
      try {
        await context.read<AuthProvider>().login(
              _emailController.text.trim(),
              _passwordController.text.trim(),
            );
        // Router otomatik yönlendirecek...
      } catch (e) {
        if (mounted) {
          ScaffoldMessenger.of(context).showSnackBar(
            SnackBar(content: Text('Hata: ${e.toString()}'), backgroundColor: Colors.red),
          );
        }
      } finally {
        if (mounted) setState(() => _isLoading = false);
      }
    }
  }

  // Şifremi Unuttum Dialogu
  void _showForgotPasswordDialog() {
    final resetEmailController = TextEditingController(text: _emailController.text);
    showDialog(
      context: context,
      builder: (context) => AlertDialog(
        title: const Text('Şifre Sıfırlama'),
        content: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            const Text('E-posta adresinizi girin, size sıfırlama bağlantısı gönderelim.'),
            const SizedBox(height: 16),
            TextField(
              controller: resetEmailController,
              decoration: const InputDecoration(
                labelText: 'E-posta',
                border: OutlineInputBorder(),
              ),
              keyboardType: TextInputType.emailAddress,
              autofillHints: const [AutofillHints.email],
            ),
          ],
        ),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(context),
            child: const Text('İptal'),
          ),
          FilledButton(
            onPressed: () async {
              final email = resetEmailController.text.trim();
              if (email.isEmpty) return;
              
              Navigator.pop(context); // Dialogu kapat
              try {
                await context.read<AuthProvider>().sendPasswordResetEmail(email);
                if (mounted) {
                  ScaffoldMessenger.of(context).showSnackBar(
                    const SnackBar(content: Text('Sıfırlama bağlantısı gönderildi.')),
                  );
                }
              } catch (e) {
                if (mounted) {
                  ScaffoldMessenger.of(context).showSnackBar(
                    SnackBar(content: Text('Hata: $e'), backgroundColor: Colors.red),
                  );
                }
              }
            },
            child: const Text('Gönder'),
          ),
        ],
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Colors.grey[100],
      body: Center(
        child: ConstrainedBox(
          constraints: const BoxConstraints(maxWidth: 400),
          child: Card(
            elevation: 4,
            shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
            margin: const EdgeInsets.all(24),
            child: Padding(
              padding: const EdgeInsets.all(32.0),
              child: AutofillGroup( // 3. MADDE: Tarayıcı Desteği İçin Kritik Kapsayıcı
                child: Form(
                  key: _formKey,
                  child: Column(
                    mainAxisSize: MainAxisSize.min,
                    crossAxisAlignment: CrossAxisAlignment.stretch,
                    children: [
                      const Icon(Icons.lock_person, size: 64, color: Colors.blue),
                      const SizedBox(height: 16),
                      Text(
                        'Yönetici Girişi',
                        textAlign: TextAlign.center,
                        style: Theme.of(context).textTheme.headlineSmall?.copyWith(fontWeight: FontWeight.bold),
                      ),
                      const SizedBox(height: 32),

                      // --- E-POSTA ---
                      TextFormField(
                        controller: _emailController,
                        decoration: const InputDecoration(
                          labelText: 'E-posta',
                          prefixIcon: Icon(Icons.email_outlined),
                          border: OutlineInputBorder(),
                        ),
                        keyboardType: TextInputType.emailAddress,
                        textInputAction: TextInputAction.next, // Enter'a basınca şifreye geç
                        autofillHints: const [AutofillHints.email], // Tarayıcıya ipucu
                        validator: (value) => (value != null && value.contains('@')) ? null : 'Geçerli e-posta giriniz',
                      ),
                      const SizedBox(height: 16),

                      // --- ŞİFRE ---
                      TextFormField(
                        controller: _passwordController,
                        obscureText: !_isPasswordVisible, // 2. MADDE: Gizle/Göster
                        decoration: InputDecoration(
                          labelText: 'Şifre',
                          prefixIcon: const Icon(Icons.lock_outline),
                          border: const OutlineInputBorder(),
                          suffixIcon: IconButton(
                            icon: Icon(
                              _isPasswordVisible ? Icons.visibility : Icons.visibility_off,
                            ),
                            onPressed: () {
                              setState(() {
                                _isPasswordVisible = !_isPasswordVisible;
                              });
                            },
                          ),
                        ),
                        textInputAction: TextInputAction.done, // Enter'a basınca formu gönder
                        onFieldSubmitted: (_) => _handleLogin(),
                        autofillHints: const [AutofillHints.password], // Tarayıcıya ipucu
                        validator: (value) => (value == null || value.isEmpty) ? 'Şifre giriniz' : null,
                      ),
                      
                      // --- ŞİFREMİ UNUTTUM ---
                      Align(
                        alignment: Alignment.centerRight,
                        child: TextButton(
                          onPressed: _showForgotPasswordDialog, // 1. MADDE
                          child: const Text('Şifremi Unuttum?'),
                        ),
                      ),
                      
                      const SizedBox(height: 8),

                      // --- GİRİŞ BUTONU ---
                      SizedBox(
                        height: 48,
                        child: ElevatedButton(
                          onPressed: _isLoading ? null : _handleLogin,
                          style: ElevatedButton.styleFrom(
                            backgroundColor: Colors.blue,
                            foregroundColor: Colors.white,
                            shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
                          ),
                          child: _isLoading
                              ? const SizedBox(height: 24, width: 24, child: CircularProgressIndicator(color: Colors.white, strokeWidth: 2))
                              : const Text('Giriş Yap', style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold)),
                        ),
                      ),
                    ],
                  ),
                ),
              ),
            ),
          ),
        ),
      ),
    );
  }
}

import {onCall, HttpsError} from "firebase-functions/v2/https";
import * as admin from "firebase-admin";

admin.initializeApp();

interface AddUserAccountData {
  email: string;
  password: string;
  displayName: string;
  role: string;
}

export const addUserAccount = onCall(async (request) => {
  // Check if the request is authenticated
  if (!request.auth) {
    throw new HttpsError(
      "unauthenticated",
      "User must be authenticated to create accounts."
    );
  }

  // Check if the caller has admin role from Firestore
  const callerUid = request.auth.uid;
  const userDoc = await admin.firestore().collection("users").doc(callerUid).get();

  if (!userDoc.exists || userDoc.data()?.role !== "admin") {
    throw new HttpsError(
      "permission-denied",
      "Only administrators can create user accounts."
    );
  }

  // Validate input data
  const {email, password, displayName, role} = request.data as AddUserAccountData;

  if (!email || typeof email !== "string") {
    throw new HttpsError(
      "invalid-argument",
      "Email is required and must be a string."
    );
  }

  if (!password || typeof password !== "string" || password.length < 6) {
    throw new HttpsError(
      "invalid-argument",
      "Password is required and must be at least 6 characters."
    );
  }

  if (!displayName || typeof displayName !== "string") {
    throw new HttpsError(
      "invalid-argument",
      "Display name is required and must be a string."
    );
  }

  if (!role || typeof role !== "string") {
    throw new HttpsError(
      "invalid-argument",
      "Role is required and must be a string."
    );
  }

  // Validate role is one of the allowed values
  const allowedRoles = ["admin", "client", "employee"];
  if (!allowedRoles.includes(role)) {
    throw new HttpsError(
      "invalid-argument",
      `Role must be one of: ${allowedRoles.join(", ")}`
    );
  }

  try {
    // Create the user account
    const userRecord = await admin.auth().createUser({
      email: email,
      password: password,
      displayName: displayName,
      emailVerified: false,
    });

    // Set custom claims for the role
    await admin.auth().setCustomUserClaims(userRecord.uid, {
      role: role,
    });

    // Create user document in Firestore
    await admin.firestore().collection("users").doc(userRecord.uid).set({
      email: email,
      displayName: displayName,
      role: role,
      createdAt: admin.firestore.FieldValue.serverTimestamp(),
      createdBy: callerUid,
      active: true,
    });

    return {
      success: true,
      message: `User ${email} created successfully with role ${role}.`,
      userId: userRecord.uid,
    };
  } catch (error: any) {
    console.error("Error creating user:", error);

    // Handle specific Firebase Auth errors
    if (error.code === "auth/email-already-exists") {
      throw new HttpsError(
        "already-exists",
        "An account with this email already exists."
      );
    }

    if (error.code === "auth/invalid-email") {
      throw new HttpsError(
        "invalid-argument",
        "The email address is invalid."
      );
    }

    if (error.code === "auth/weak-password") {
      throw new HttpsError(
        "invalid-argument",
        "The password is too weak."
      );
    }

    // Generic error
    throw new HttpsError(
      "internal",
      `Failed to create user: ${error.message}`
    );
  }
});