syncrow-app/lib/features/menu/bloc/profile_bloc/profile_bloc.dart

import 'dart:convert';
import 'dart:io';
import 'package:device_info_plus/device_info_plus.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:syncrow_app/features/auth/bloc/auth_cubit.dart';
import 'package:syncrow_app/features/menu/bloc/profile_bloc/profile_event.dart';
import 'package:syncrow_app/features/menu/bloc/profile_bloc/profile_state.dart';
import 'package:syncrow_app/features/menu/bloc/profile_bloc/region_model.dart';
import 'package:syncrow_app/features/menu/bloc/profile_bloc/time_zone_model.dart';
import 'package:syncrow_app/services/api/profile_api.dart';
import 'package:syncrow_app/utils/helpers/snack_bar.dart';
import 'package:image_picker/image_picker.dart';
import 'package:permission_handler/permission_handler.dart';

class ProfileBloc extends Bloc<ProfileEvent, ProfileState> {
  bool isSaving = false;
  bool editName = false;
  final FocusNode focusNode = FocusNode();
  File? image;
  final ImagePicker _picker = ImagePicker();
  String timeZoneSelected = '';
  String regionSelected = '';
  final TextEditingController searchController = TextEditingController();
  final TextEditingController nameController = TextEditingController(text: '${AuthCubit.user!.firstName} ${AuthCubit.user!.lastName}');
  List<TimeZone>? timeZoneList;
  List<RegionModel>? regionList;


  ProfileBloc() : super(InitialState()) {
    on<InitialProfileEvent>(_fetchUserInfo);
    on<TimeZoneInitialEvent>(_fetchTimeZone);
    on<RegionInitialEvent>(_fetchRegion);
    on<SaveNameEvent>(saveName);
    on<SelectImageEvent>(_selectImage);
    on<ChangeNameEvent>(_changeName);
    on<SelectTimeZoneEvent>(selectTimeZone);
    on<SearchRegionEvent>(searchRegion);
    on<SearchTimeZoneEvent>(searchTimeZone);
    on<SelectRegionEvent>(selectRegion);
  }

  Uint8List? decodeBase64Image(String? base64String) {
    if (base64String != null) {
      final startIndex = base64String.indexOf('base64,') + 7;
      final pureBase64String = base64String.substring(startIndex);
      return base64.decode(pureBase64String);
    }
    return null;
  }
  void _changeName(ChangeNameEvent event, Emitter<ProfileState> emit) {
    emit(LoadingInitialState());
    editName = event.value!;
    if (editName) {
      Future.delayed(const Duration(milliseconds: 500), () {
        focusNode.requestFocus();
      });
    }else {
      focusNode.unfocus();
    }
    emit(NameEditingState(editName: editName));
  }

  void _fetchUserInfo(InitialProfileEvent event, Emitter<ProfileState> emit) async {
    try {
      emit(LoadingInitialState());
      AuthCubit.user = await ProfileApi.fetchUserInfo(AuthCubit.user!.uuid);
      emit(SaveState());
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
      return;
    }
  }

  Future _fetchTimeZone(TimeZoneInitialEvent event, Emitter<ProfileState> emit) async {
    emit(LoadingInitialState());
    try {
      timeZoneList = await ProfileApi.fetchTimeZone();
      emit(UpdateState(timeZoneList: timeZoneList!));
      return timeZoneList;
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
      return;
    }
  }


  Future selectTimeZone(SelectTimeZoneEvent event, Emitter<ProfileState> emit) async {
    try {
      emit(LoadingInitialState());
      timeZoneSelected = event.val;
      await ProfileApi.saveTimeZone(regionUuid: event.val);
      CustomSnackBar.displaySnackBar('Save Successfully');
      emit(SaveState());
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
    }
  }

  Future selectRegion(SelectRegionEvent event, Emitter<ProfileState> emit) async {
    try {
      emit(LoadingInitialState());
      await ProfileApi.saveRegion(regionUuid:event.val );
      CustomSnackBar.displaySnackBar('Save Successfully');
      emit(SaveState());
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
      return;
    }
  }

  Future searchRegion(SearchRegionEvent event, Emitter<ProfileState> emit) async {
    emit(LoadingInitialState());
    final query = event.query.toLowerCase();
    if(event.query.isNotEmpty){
      final filteredRegions = regionList?.where((region) {
        return region.name.toLowerCase().contains(query);
      }).toList() ?? [];
      regionList = filteredRegions;// Assume this fetches the regions
      emit(RegionsLoadedState(regions: filteredRegions));
    }else{
      regionList = await ProfileApi.fetchRegion();
      emit(RegionsLoadedState(regions: regionList!));
    }
  }

  Future searchTimeZone(SearchTimeZoneEvent event, Emitter<ProfileState> emit) async {
    emit(LoadingInitialState());
    final query = event.query.toLowerCase();
    if(event.query.isNotEmpty){
      final filtered = timeZoneList?.where((region) {
        return region.name.toLowerCase().contains(query);
      }).toList() ?? [];
      timeZoneList = filtered;
      emit(TimeZoneLoadedState(regions: filtered));
    }else{
      timeZoneList = await ProfileApi.fetchTimeZone();
      emit(UpdateState(timeZoneList: timeZoneList!));
    }
  }


  void _fetchRegion(RegionInitialEvent event, Emitter<ProfileState> emit) async {
    try {
      emit(LoadingInitialState());
      regionList = await ProfileApi.fetchRegion();
      emit(RegionsLoadedState(regions: regionList!));
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
    }
  }

  Future<void> _selectImage(SelectImageEvent event, Emitter<ProfileState> emit) async {
    if (await _requestPermission()) {
      emit(ChangeImageState());
      final pickedFile = await _picker.pickImage(source: ImageSource.gallery);
      if (pickedFile != null) {
        image = File(pickedFile.path);
        final bytes = image!.readAsBytesSync().lengthInBytes;
        final kb = bytes / 1024;
        final mb = kb / 1024;
        if(mb>1){
          image=null;
          CustomSnackBar.displaySnackBar('Image size must be 1 MB or less');
        }else{
          await _saveImage();
        }
      } else {
        print('No image selected.');
      }
      emit(ImageSelectedState());
    } else {
      _showPermissionDeniedDialog(event.context);
    }
  }

  Future<void> _saveImage() async {
    emit(LoadingInitialState());
    List<int> imageBytes = image!.readAsBytesSync();
    String base64Image = base64Encode(imageBytes);
    print(base64Image);
    var response = await ProfileApi.saveImage(base64Image);
    emit(ImageSelectedState());
  }

  void _showPermissionDeniedDialog(BuildContext context) {
    showDialog(
      context: context,
      builder: (BuildContext context) {
        return AlertDialog(
          title: const Text('Permission Denied'),
          content: const Text(
              'Photo access is required to select an image. Please allow photo access in the app settings.'),
          actions: [
            TextButton(
              onPressed: () {
                Navigator.of(context).pop();
              },
              child: const Text('Cancel'),
            ),
            TextButton(
              onPressed: () {
                openAppSettings();
              },
              child: const Text('Settings'),
            ),
          ],
        );
      },
    );
  }

  Future<void> saveName(SaveNameEvent event, Emitter<ProfileState> emit) async {
    if (_validateInputs()) return;
    try {
      add(const ChangeNameEvent(value: false));
      isSaving = true;
      emit(LoadingInitialState());
      final fullName = nameController.text;
      final nameParts = fullName.split(' ');
      final firstName = nameParts[0];
      final lastName = nameParts.length > 1 ? nameParts[1] : '';
      var response = await ProfileApi.saveName(firstName: firstName, lastName: lastName);
      add(InitialProfileEvent());
      AuthCubit.get(event.context).fetchUserInfo();
      Navigator.of(event.context).pop(true);
      CustomSnackBar.displaySnackBar('Save Successfully');
      emit(SaveState());
    } catch (_) {
      // Handle the error
    } finally {
      isSaving = false;
    }
  }

  bool _validateInputs() {
    if (nameController.text.length < 2) {
      CustomSnackBar.displaySnackBar('Name Must More than 2 ');
      return true;
    }
    return false;
  }

  Future<bool> _requestPermission() async {
    DeviceInfoPlugin deviceInfo = DeviceInfoPlugin();
    if (Platform.isAndroid ) {
      AndroidDeviceInfo androidInfo = await deviceInfo.androidInfo;
      PermissionStatus status = await Permission.photos.status;
      if(androidInfo.version.sdkInt<= 33){
        if (status.isDenied) {
          PermissionStatus status = await Permission.storage.request();
          if (status.isGranted) {
            return true;
          } else {
            return false;
          }
        }
      }else{
        if (status.isGranted) {
          return true;
        } else if (status.isDenied) {
          PermissionStatus status = await Permission.photos.request();
          if (status.isGranted) {
            return true;
          } else {
            return false;
          }
        }
      }
      return false;
    } else {
      SharedPreferences sharedPreferences = await SharedPreferences.getInstance();
      bool firstClick = sharedPreferences.getBool('firstPermission') ?? true;
      await sharedPreferences.setBool('firstPermission', false);
      if (firstClick == false) {
        var status = await Permission.photos.status;
        return status.isGranted;
      } else {
        return true;
      }
    }
  }

}