import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:flutter/foundation.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:http/http.dart' as http;
import 'package:shared_preferences/shared_preferences.dart';
import 'package:geolocator/geolocator.dart';

import 'package:doormile/core/constants/api_constants.dart';

import 'package:doormile/shared/models/models.dart';
import 'package:doormile/core/theme/app_colors.dart';

/// Holds the in-progress booking the user is composing across the flow screens.
class BookingDraft {
  String pickupAddress = '';
  String pickupPincode = '';
  double pickupLatitude = 0.0;
  double pickupLongitude = 0.0;
  String contactName = '';
  String contactMobile = '';
  String notes = '';

  String destination = '';
  String service = '';
  String parcelType = '';
  String weight = '2 kg';
  String size = 'Small';
  String pickupDay = 'Today';
  String pickupSlot = '10:00 AM - 12:00 PM';
  bool fragile = false;
  String dropAddress = '';
  String dropPincode = '';
  String paymentMethod = 'Cash';
  bool needsInsurance = false;
  double declaredValue = 0.0;

  double minPrice = 45.0;
  double maxPrice = 86.0;

  void reset() {
    pickupAddress = '';
    pickupPincode = '';
    pickupLatitude = 0.0;
    pickupLongitude = 0.0;
    contactName = '';
    contactMobile = '';
    notes = '';
    destination = '';
    service = '';
    parcelType = '';
    weight = '2 kg';
    size = 'Small';
    pickupDay = 'Today';
    pickupSlot = '10:00 AM - 12:00 PM';
    fragile = false;
    dropAddress = '';
    dropPincode = '';
    paymentMethod = 'Cash';
    needsInsurance = false;
    declaredValue = 0.0;
    minPrice = 45.0;
    maxPrice = 86.0;
  }
}

/// Global, in-memory app state — auth, wallet, orders, and the booking draft.
class AppState extends ChangeNotifier {
  // ---- Auth ----
  bool isLoggedIn = false;
  String phone = '';
  String? verificationId;
  String userName = ''; // Updated via profile/login
  String firstName = '';
  
  String? pendingFirstName;
  String? pendingEmail;
  String? authToken;
  bool isResettingPin = false;
  String? _deviceToken;

  AppState() {
    _loadSession();
  }

  Future<void> _loadSession() async {
    final prefs = await SharedPreferences.getInstance();
    authToken = prefs.getString('auth_token');
    if (authToken != null && authToken!.isNotEmpty) {
      isLoggedIn = true;
      firstName = prefs.getString('first_name') ?? 'User';
      userName = prefs.getString('user_name') ?? 'User';
      phone = prefs.getString('phone') ?? '';
      
      // Wipe mock data because this is a real authenticated session
      orders.clear();
      savedAddresses.clear();
      
      notifyListeners();
    }
  }

  Future<void> _saveSession() async {
    final prefs = await SharedPreferences.getInstance();
    if (authToken != null) await prefs.setString('auth_token', authToken!);
    await prefs.setString('first_name', firstName);
    await prefs.setString('user_name', userName);
    await prefs.setString('phone', phone);
  }

  Future<String?> _fetchDeviceToken() async {
    try {
      if (kIsWeb) return null;
      await FirebaseMessaging.instance.requestPermission(alert: true, badge: true, sound: true);
      _deviceToken = await FirebaseMessaging.instance.getToken();
      return _deviceToken;
    } catch (e) {
      debugPrint('FCM token error: $e');
      return null;
    }
  }

  void setPhone(String value) {
    phone = value;
    notifyListeners();
  }

  /// Sends a 6-digit OTP to [phoneNumber] via Firebase Phone Auth.
  Future<void> sendOtp(String phoneNumber, {String? firstName, String? email, bool resetPin = false, required Function onSuccess, required Function(String) onError}) async {
    setPhone(phoneNumber);
    pendingFirstName = firstName ?? pendingFirstName;
    pendingEmail = email ?? pendingEmail;
    isResettingPin = resetPin;

    final rawPhone = phoneNumber.replaceAll(' ', '');
    if (rawPhone.length != 10) {
      onError('A valid mobile number is required for verification.');
      return;
    }
    final fullPhone = '+91$rawPhone';

    if (kIsWeb) {
      debugPrint('[OTP Service] Web build: bypassing Firebase OTP (mocking success)');
      Future.delayed(const Duration(seconds: 1), () {
        verificationId = 'mock_verification_id_$fullPhone';
        onSuccess();
      });
      return;
    }

    try {
      debugPrint('[OTP Service] Initiating Firebase phone verification for $fullPhone');
      await FirebaseAuth.instance.verifyPhoneNumber(
        phoneNumber: fullPhone,
        verificationCompleted: (PhoneAuthCredential credential) async {
          debugPrint('[OTP Service] Verification completed automatically');
          try {
            await FirebaseAuth.instance.signInWithCredential(credential);
          } catch (e) {
            debugPrint('[OTP Service] Error signing in: $e');
          }
        },
        verificationFailed: (FirebaseAuthException e) {
          debugPrint('[OTP Service] Verification failed: ${e.code} - ${e.message}');
          onError(e.message ?? 'Failed to send verification code.');
        },
        codeSent: (String vId, int? resendToken) {
          debugPrint('[OTP Service] Code sent. Verification ID: $vId');
          verificationId = vId;
          onSuccess();
        },
        codeAutoRetrievalTimeout: (String vId) {
          debugPrint('[OTP Service] Auto retrieval timeout. Verification ID: $vId');
          verificationId = vId;
        },
      );
    } catch (e) {
      debugPrint('[OTP Service] Exception during OTP request: $e');
      onError('Error sending verification code: $e');
    }
  }

  /// Debug-only tester shortcut: if `smsDefaultProvider`/`smsPassKey` are set
  /// in SharedPreferences, that fixed passkey is accepted instead of the real
  /// OTP. `kDebugMode` means this branch is compiled out of release builds
  /// entirely, so it can never ship as a bypass.
  Future<bool> _checkDebugBypass(String smsCode) async {
    if (!kDebugMode) return false;
    final prefs = await SharedPreferences.getInstance();
    final provider = prefs.getInt('smsDefaultProvider') ?? 0;
    final passKey = prefs.getInt('smsPassKey');
    return provider == 1 && passKey != null && smsCode == passKey.toString().padLeft(6, '0');
  }

  Future<void> verifyOtp(String smsCode, {required Function onSuccess, required Function(String) onError}) async {
    if (await _checkDebugBypass(smsCode)) {
      onSuccess();
      return;
    }

    if (verificationId == null) {
      onError('Verification ID is missing. Please resend OTP.');
      return;
    }

    if (kIsWeb) {
      debugPrint('[OTP Service] Web build: bypassing Firebase OTP verification (mocking success)');
      if (smsCode.length == 6) {
        onSuccess();
      } else {
        onError('Invalid mock OTP code (must be 6 digits).');
      }
      return;
    }

    try {
      final credential = PhoneAuthProvider.credential(
        verificationId: verificationId!,
        smsCode: smsCode,
      );
      await FirebaseAuth.instance.signInWithCredential(credential);
      onSuccess();
    } catch (e) {
      onError('Invalid verification code.');
    }
  }

  // --- Backend Wrappers ---

  Future<void> registerWithPin(String pin) async {
    final rawPhone = phone.replaceAll(' ', '');
    final parts = (pendingFirstName ?? 'User').split(' ');
    final first = parts.first;
    final last = parts.length > 1 ? parts.sublist(1).join(' ') : '';
    
    double lat = 0.0;
    double lng = 0.0;

    try {
      bool serviceEnabled = await Geolocator.isLocationServiceEnabled();
      if (serviceEnabled) {
        LocationPermission permission = await Geolocator.checkPermission();
        if (permission == LocationPermission.denied) {
          permission = await Geolocator.requestPermission();
        }
        if (permission == LocationPermission.whileInUse || permission == LocationPermission.always) {
          Position position = await Geolocator.getCurrentPosition(desiredAccuracy: LocationAccuracy.medium);
          lat = position.latitude;
          lng = position.longitude;
        }
      }
    } catch (e) {
      debugPrint('Error getting location for registration: $e');
    }

    final token = await _fetchDeviceToken();

    final res = await http.post(
      Uri.parse(ApiConstants.register),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        "firstname": first,
        "lastname": last,
        "phone": rawPhone,
        "email": pendingEmail ?? '',
        "pin": pin,
        "configid": 1001,
        "defaultlatitude": lat,
        "defaultlongitude": lng,
        if (token != null) "device_token": token,
      }),
    );
    if (res.statusCode >= 200 && res.statusCode < 300) {
      final data = jsonDecode(res.body);
      authToken = data['token'];
      
      if (data['user'] != null && data['user']['firstname'] != null) {
        firstName = data['user']['firstname'];
        userName = '$firstName ${data['user']['lastname'] ?? ''}'.trim();
      } else {
        firstName = pendingFirstName ?? 'User';
        userName = pendingFirstName ?? 'User';
      }
      
      login();
    } else {
      throw Exception('Registration Failed: ${res.body}');
    }
  }

  Future<void> initiateLogin(String phoneNumber) async {
    final rawPhone = phoneNumber.replaceAll(' ', '');
    setPhone(phoneNumber);
    
    // Easter Egg
    if (rawPhone == '9876543210') {
      return; 
    }
    
    final initRes = await http.post(
      Uri.parse(ApiConstants.login),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({"phone": rawPhone, "configid": 1001}),
    );
    
    if (initRes.statusCode < 200 || initRes.statusCode >= 300) {
      throw Exception('Phone number not registered. Please sign up first.');
    }
  }

  Future<void> verifyPinWithBackend(String pin) async {
    final rawPhone = phone.replaceAll(' ', '');
    
    // Easter Egg
    if (rawPhone == '9876543210' && pin == '1234') {
      authToken = 'easter-egg-token';
      firstName = 'Admin';
      userName = 'Admin User';
      login();
      return;
    }

    final token = await _fetchDeviceToken();

    final verifyRes = await http.post(
      Uri.parse(ApiConstants.verifyPin),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        "phone": rawPhone,
        "pin": pin,
        "configid": 1001,
        if (token != null) "device_token": token,
      }),
    );

    if (verifyRes.statusCode >= 200 && verifyRes.statusCode < 300) {
      final data = jsonDecode(verifyRes.body);
      authToken = data['token'];
      if (data['user'] != null && data['user']['firstname'] != null) {
        firstName = data['user']['firstname'];
        userName = '$firstName ${data['user']['lastname'] ?? ''}'.trim();
      }
      login();
    } else {
      throw Exception('Incorrect PIN. Please try again.');
    }
  }

  Future<void> resetPinWithBackend(String newPin) async {
    final rawPhone = phone.replaceAll(' ', '');
    // TODO: Create this endpoint in Go backend
    final res = await http.post(
      Uri.parse('${ApiConstants.baseUrl}/customer/reset-pin'),
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({"phone": rawPhone, "new_pin": newPin}),
    );
    
    if (res.statusCode >= 200 && res.statusCode < 300) {
      final data = jsonDecode(res.body);
      if (data['token'] != null) authToken = data['token'];
      login();
    } else {
      throw Exception('PIN Reset Failed: ${res.body}');
    }
  }

  void login() {
    isLoggedIn = true;
    orders.clear();
    savedAddresses.clear();
    _saveSession();
    notifyListeners();
  }

  Future<void> logout() async {
    isLoggedIn = false;
    authToken = null;
    firstName = 'User';
    userName = 'User';
    phone = '';
    verificationId = null;
    pendingFirstName = null;
    pendingEmail = null;
    orders.clear();
    savedAddresses.clear();
    notifyListeners();
    final prefs = await SharedPreferences.getInstance();
    await prefs.remove('auth_token');
    await prefs.remove('first_name');
    await prefs.remove('user_name');
    await prefs.remove('phone');
  }

  // ---- Booking draft ----
  final BookingDraft draft = BookingDraft();
  void touch() => notifyListeners();


  // ---- Orders ----
  List<Order> orders = [];

  bool isLoadingOrders = false;

  /// Fetches real bookings from the Go backend
  Future<void> fetchOrders() async {
    if (authToken == null) return;
    
    isLoadingOrders = true;
    notifyListeners();

    if (authToken == 'easter-egg-token') {
      await Future.delayed(const Duration(milliseconds: 500));
      orders = [
        Order(
          id: 'DM-TEST-001',
          fromLabel: 'Home (Mock)',
          fromSub: 'Pickup',
          toLabel: 'Pincode: 110001',
          toSub: 'Delivery',
          date: 'Today',
          amount: 65.0,
          status: OrderStatus.active,
          progress: 0.1,
          eta: '10 min',
        ),
      ];
      isLoadingOrders = false;
      notifyListeners();
      return;
    }

    try {
      print('\n=== DOORMILE API FETCH ORDERS ===');
      print('Endpoint: ${ApiConstants.getPickups}');
      
      final res = await http.get(
        Uri.parse(ApiConstants.getPickups),
        headers: {
          'Content-Type': 'application/json',
          'Authorization': 'Bearer $authToken',
        },
      );
      
      print('Status Code: ${res.statusCode}');
      
      if (res.statusCode >= 200 && res.statusCode < 300) {
        final List<dynamic> data = jsonDecode(res.body);
        
        orders = data.map((b) {
          return Order(
            id: b['booking_no'] ?? 'DM-UNK',
            fromLabel: b['pickupaddress'] ?? 'Unknown Location',
            fromSub: 'Pickup',
            toLabel: b['deliverypincode'] != null ? 'Pincode: ${b['deliverypincode']}' : 'Pending Destination',
            toSub: 'Delivery',
            date: b['created_at']?.split('T')[0] ?? 'Today',
            amount: (b['estimated_price'] ?? 0.0).toDouble(),
            status: _parseBackendStatus(b['status']),
            progress: b['status'] == 'Pending_Pickup' ? 0.1 : 0.5,
          );
        }).toList();
      }
    } catch (e) {
      print('Failed to fetch orders: $e');
    } finally {
      isLoadingOrders = false;
      notifyListeners();
    }
  }

  OrderStatus _parseBackendStatus(String? status) {
    if (status == 'Pending_Pickup') return OrderStatus.active;
    if (status == 'Delivered') return OrderStatus.delivered;
    if (status == 'Cancelled') return OrderStatus.cancelled;
    return OrderStatus.active;
  }

  /// Fetches estimated pricing from the Redis-backed Go API
  Future<void> fetchPriceEstimate() async {
    // Map UI categories to Backend enums
    String backendCategory = "General";
    switch (draft.parcelType) {
      case "General Goods": backendCategory = "General"; break;
      case "Books & Documents": backendCategory = "Documents"; break;
      case "Electronics & Gadgets": backendCategory = "Electronics"; break;
      case "Clothing & Textiles": backendCategory = "Clothing"; break;
      case "Fragile Items": backendCategory = "Fragile"; break;
      case "Medical & Pharma": backendCategory = "Medical"; break;
      case "Automotive Parts": backendCategory = "Automotive"; break;
      case "Food & Perishables": backendCategory = "Food"; break;
      default: backendCategory = "General";
    }

    final payload = {
      "zone": "Local",
      "destinationpin": draft.dropPincode,
      "pickuppincode": draft.pickupPincode,
      "service_type": draft.service.isNotEmpty ? draft.service : "Normal",
      "weight": 1.0, // Default since we removed it from UI
      "category": backendCategory
    };

    print('\n=== DOORMILE API PRICING REQUEST ===');
    print('Endpoint: ${ApiConstants.checkPrice}');
    print('Payload: ${jsonEncode(payload)}');
    print('====================================\n');

    if (authToken == 'easter-egg-token') {
      await Future.delayed(const Duration(milliseconds: 500));
      draft.minPrice = 50.0;
      draft.maxPrice = 120.0;
      notifyListeners();
      return;
    }

    try {
      final res = await http.post(
        Uri.parse(ApiConstants.checkPrice),
        headers: {'Content-Type': 'application/json'},
        body: jsonEncode(payload),
      );

      print('\n=== DOORMILE API PRICING RESPONSE ===');
      print('Status Code: ${res.statusCode}');
      print('Response Body: ${res.body}');
      print('=============================\n');

      if (res.statusCode >= 200 && res.statusCode < 300) {
        final data = jsonDecode(res.body);
        if (data['results'] != null && data['results'].isNotEmpty) {
          final result = data['results'][0];
          draft.minPrice = (result['min_price'] as num).toDouble();
          draft.maxPrice = (result['max_price'] as num).toDouble();
          notifyListeners();
        }
      }
    } catch (e) {
      print('Pricing API error: $e');
      // On error, we just keep the default 45 - 86 fallback
    }
  }

  /// Confirms the current draft into a new active order.
  Future<Order> placeOrder() async {
    // Map UI categories to Backend enums
    String backendCategory = "General";
    switch (draft.parcelType) {
      case "General Goods": backendCategory = "General"; break;
      case "Books & Documents": backendCategory = "Documents"; break;
      case "Electronics & Gadgets": backendCategory = "Electronics"; break;
      case "Clothing & Textiles": backendCategory = "Clothing"; break;
      case "Fragile Items": backendCategory = "Fragile"; break;
      case "Medical & Pharma": backendCategory = "Medical"; break;
      case "Automotive Parts": backendCategory = "Automotive"; break;
      case "Food & Perishables": backendCategory = "Food"; break;
      default: backendCategory = "General";
    }

    final payload = {
      "pickupaddress": draft.pickupAddress.isNotEmpty ? draft.pickupAddress : "Current Location (GPS)",
      "pickuppincode": draft.pickupPincode,
      "pickuplatitude": draft.pickupLatitude,
      "pickuplongitude": draft.pickupLongitude,
      "deliverypincode": draft.dropPincode,
      "deliveryaddress": draft.dropAddress,
      "serviceoption": draft.service,
      "contactname": draft.contactName,
      "contactmobile": draft.contactMobile,
      "parcels": [
        {
          "itemcategory": backendCategory,
          "itemdescription": draft.notes.isNotEmpty ? draft.notes : "No description provided"
        }
      ]
    };

    print('\n=== DOORMILE API BOOKING REQUEST ===');
    print('Endpoint: ${ApiConstants.createPickup}');
    print('Payload: ${jsonEncode(payload)}');
    print('====================================\n');

    if (authToken == 'easter-egg-token') {
      await Future.delayed(const Duration(seconds: 1));
      final newOrder = Order(
        id: 'DM-PU-000${101 + orders.length}',
        fromLabel: draft.pickupAddress,
        fromSub: draft.contactName.isEmpty ? 'Pickup requested' : 'Contact: ${draft.contactName}',
        toLabel: draft.dropPincode.isNotEmpty ? 'Pincode: ${draft.dropPincode}' : 'Awaiting Miler input',
        toSub: 'Drop details pending',
        date: 'Today',
        amount: draft.minPrice,
        status: OrderStatus.active,
        progress: 0.1,
        eta: 'Assigning Miler...',
      );
      
      orders.insert(0, newOrder);
      draft.reset();
      notifyListeners();
      return newOrder;
    }

    final res = await http.post(
      Uri.parse(ApiConstants.createPickup),
      headers: {
        'Content-Type': 'application/json',
        if (authToken != null) 'Authorization': 'Bearer $authToken',
      },
      body: jsonEncode(payload),
    );

    print('\n=== DOORMILE API RESPONSE ===');
    print('Status Code: ${res.statusCode}');
    print('Response Body: ${res.body}');
    print('=============================\n');

    if (res.statusCode >= 200 && res.statusCode < 300) {
      final data = jsonDecode(res.body);
      
      final newOrder = Order(
        id: data['booking_no'] ?? 'DM-PU-000${101 + orders.length}',
        fromLabel: draft.pickupAddress,
        fromSub: draft.contactName.isEmpty ? 'Pickup requested' : 'Contact: ${draft.contactName}',
        toLabel: draft.dropPincode.isNotEmpty ? 'Pincode: ${draft.dropPincode}' : 'Awaiting Miler input',
        toSub: 'Drop details pending',
        date: 'Today',
        amount: draft.minPrice,
        status: OrderStatus.active,
        progress: 0.1,
        eta: 'Assigning Miler...',
      );
      
      orders.insert(0, newOrder);
      draft.reset();
      notifyListeners();
      return newOrder;
    } else {
      throw Exception('Failed to create pickup request: ${res.body}');
    }
  }

  // ---- Saved addresses ----
  List<AddressEntry> savedAddresses = [
    AddressEntry(
      label: 'Home',
      line: 'Sector 45, Gurgaon, Haryana, 122003',
      icon: Icons.home_rounded,
      iconBg: AppColors.primaryFixed,
      iconColor: AppColors.primary,
      pincode: '122003',
    ),
    AddressEntry(
      label: 'Work',
      line: 'Cyber City Building 10, DLF Phase 2',
      icon: Icons.work_rounded,
      iconBg: AppColors.tertiaryFixed,
      iconColor: AppColors.tertiary,
      pincode: '122002',
    ),
    AddressEntry(
      label: 'Select City Walk Mall',
      line: 'Saket District Centre, New Delhi',
      icon: Icons.history_rounded,
      iconBg: AppColors.surfaceContainerHigh,
      iconColor: AppColors.onSurfaceVariant,
      pincode: '110017',
    ),
  ];


}