import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';
import 'dart:ui' as ui;

import 'package:cached_network_image/cached_network_image.dart';
import 'package:dio/dio.dart';
// import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
import 'package:hive/hive.dart';
import 'package:image_picker/image_picker.dart';
import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';
import 'package:stripe_payment/stripe_payment.dart';

import '../constants.dart';
import '../events/eventbus.dart';
import '../events/events.dart';
import '../generated/l10n.dart';
import '../models/comment.dart';
import '../models/order.dart';
import '../models/payment_platform.dart';
import '../models/stripe_payment_method.dart';
import '../models/user.dart';
import '../routes.dart';
import '../store/actions.dart';
import '../store/store.dart';
import '../widgets/general/stripe_pay.dart';
import 'http_util.dart';
import 'utils.dart';

typedef void OnGotFile(int imageId, String filePath);

class Util {
  static final Util _util = Util._internal();
  factory Util() {
    return _util;
  }
  Util._internal();

  // final FirebaseMessaging firebaseMessaging = FirebaseMessaging();
  final FlutterLocalNotificationsPlugin flutterLocalNotificationsPlugin = new FlutterLocalNotificationsPlugin();
  static bool notificationTapped = false;

  init() {
    // initLocalNotification();
    // initFirebaseMessaging();

    // ePmqRwRUTmKuFNfbHA-6zq:APA91bEFEQx1YgJqfx0V0VYo86uRDGjG6SP1SPCAZW4OvQ7gMOeKWDQ47bfuEM00YavtKq7ZGpsWfFL7B3ypm00ZA6crjJJLK_-j_H8bS_dnQbLFwyRcW67IXCs5sRkro71bRZv7L1WM

    // eventBus.on<SubscribeToTopic>().listen((event) {
    //   if (firebaseMessaging != null) {
    //     firebaseMessaging.subscribeToTopic(event.topic);
    //   }
    // });
    // eventBus.on<UnSubscribeToTopic>().listen((event) {
    //   if (firebaseMessaging != null) {
    //     firebaseMessaging.unsubscribeFromTopic(event.topic);
    //   }
    // });
  }

  initLocalNotification() async {
    var initializationSettingsAndroid = new AndroidInitializationSettings('ic_launcher');
    var initializationSettingsIOS = new IOSInitializationSettings(
        onDidReceiveLocalNotification: onDidReceiveLocalNotification);
    var initializationSettings = new InitializationSettings(
      android: initializationSettingsAndroid,
      iOS: initializationSettingsIOS,
    );
    await flutterLocalNotificationsPlugin.initialize(initializationSettings,
        onSelectNotification: onSelectNotification);
  }

  Future onSelectNotification(String payload, {bool replace=false}) async {
    print('payload: $payload');
    if (payload != null && payload.isNotEmpty) {
      Routes.router.navigateTo(store.state.context, payload, replace: replace);
    }
  }

//   initFirebaseMessaging() {
//     if (Platform.isIOS) {
//       iosPermission();
//     }
//     firebaseMessaging.getToken().then((token) {
//       print('FCM token: $token');
//       store.dispatch(UpdateFcmToken(token));
//     });
//     firebaseMessaging.configure(
//       onMessage: (Map<String, dynamic> message) {
//         print('FCM onMessage: $message');
// //        eventBus.fire(OnFcmReceived(message));
//         showNotificationWithDefaultSound(message);
//         return;
//       },
//       onBackgroundMessage: Platform.isIOS ? null : backgroundMessageHandler,
//       onResume: (Map<String, dynamic> message) {
//         print('FCM onResume: $message');
//         if (Platform.isAndroid) {
//           if (message != null && message['data'] != null && message['data']['route'] != null) {
//             notificationTapped = true;
//             onSelectNotification(message['data']['route']);
//           }
//         } else {
//           if (message != null && message['route'] != null) {
//             notificationTapped = true;
//             onSelectNotification(message['route']);
//           }
//         }
//         return;
//       },
//       onLaunch: (Map<String, dynamic> message) {
//         print('FCM onLaunch: $message');
//         if (Platform.isAndroid) {
//           if (message != null && message['data'] != null && message['data']['route'] != null) {
//             notificationTapped = true;
//             onSelectNotification(message['data']['route'], replace: true);
//           }
//         } else {
//           if (message != null && message['route'] != null) {
//             notificationTapped = true;
//             onSelectNotification(message['route'], replace: true);
//           }
//         }
//         return;
//       },
//     );
//   }

  Future onDidReceiveLocalNotification(int id, String title, String body, String payload) async {
    showDialog(
      context: store.state.context,
      builder: (BuildContext context) => CupertinoAlertDialog(
        title: Text(title),
        content: Text(body),
        actions: [
          CupertinoDialogAction(
            isDefaultAction: true,
            child: Text(S.of(context).ok),
            onPressed: () async {
              Navigator.of(context, rootNavigator: true).pop();
              if (payload != null && payload.isNotEmpty) {
                Routes.router.navigateTo(context, payload);
              }
            },
          )
        ],
      ),
    );
  }

  Future showNotificationWithDefaultSound(Map<String, dynamic> message) async {
    var androidPlatformChannelSpecifics = new AndroidNotificationDetails(
      'channelId',
      'channelName',
      'channelDescription',
      importance: Importance.max,
      priority: Priority.high,
    );
    var iOSPlatformChannelSpecifics = new IOSNotificationDetails(presentSound: true, badgeNumber: 1);
    var platformChannelSpecifics = new NotificationDetails(
      android: androidPlatformChannelSpecifics,
      iOS: iOSPlatformChannelSpecifics,
    );
    await flutterLocalNotificationsPlugin.show(
      0,
      Platform.isAndroid ? message['notification']['title'] : message['title'],
      Platform.isAndroid ? message['notification']['body'] : message['body'],
      platformChannelSpecifics,
      payload: Platform.isAndroid ? message['data']['route'] : message['route'],
    );
  }

  // iosPermission() {
  //   firebaseMessaging.requestNotificationPermissions(
  //       const IosNotificationSettings(
  //         sound: true,
  //         badge: true,
  //         alert: true,
  //       )
  //   );
  //   firebaseMessaging.onIosSettingsRegistered.listen((IosNotificationSettings settings) {
  //     print('IOS settings registered: $settings');
  //   });
  // }

  static Future<dynamic> backgroundMessageHandler(Map<String, dynamic> message) {
    print('FCM background message handler: $message');
    return Future<void>.value();
  }

  static Future<Box> getBox() async {
    final dir = await getApplicationDocumentsDirectory();
    Hive.init(dir.path);
    Box box = await Hive.openBox('app_data');
    return box;
  }

  static Widget showImage(String imageUrl, {double width, double height,
    BoxFit fit, Widget Function(BuildContext, String, dynamic) errorWidget}) {
    if (imageUrl != null && imageUrl.isNotEmpty && imageUrl.startsWith('https:')) {
      return CachedNetworkImage(
        imageUrl: imageUrl,
        width: width,
        height: width,
        fit: fit,
        placeholder: (context, url) => Utils.imageLoadingIndicator(width: width, height: height),
        errorWidget: errorWidget != null ? errorWidget : (context, url, error) {
          return Image.asset(
            'assets/images/not_found.png',
            width: width,
            height: height,
            fit: fit,
          );
        },
      );
    } else if (imageUrl != null && imageUrl.isNotEmpty) {
      return Image.file(
        File(imageUrl),
        width: width,
        height: height,
        fit: fit,
        errorBuilder: (BuildContext context, Object object, StackTrace stackTrace) {
          return Image.asset(
            'assets/images/not_found.png',
            width: width,
            height: height,
            fit: fit,
          );
        },
      );
    } else {
      return Image.asset(
        'assets/images/not_found.png',
        width: width,
        height: height,
        fit: fit,
      );
    }
  }

  static void openWebUrl(BuildContext context, String link) {
    Routes.router.navigateTo(context, '/webview/$link');
  }

  AlertDialog getPicture(BuildContext context, User user, {int commentId = -1, int orderId = 0}) {
    return AlertDialog(
      title: Text(
        S.of(context).get_picture,
      ),
      content: Container(
        height: 130.0,
        child: Column(
          children: <Widget>[
            Container(
              margin: EdgeInsets.only(bottom: 12.0),
              child: Text(
                S.of(context).get_picture_from,
                style: TextStyle(
                  fontSize: 15.0,
                  color: Colors.black26,
                ),
              ),
            ),
            Container(
              child: TextButton(
                child: Row(
                  mainAxisAlignment: MainAxisAlignment.start,
                  children: <Widget>[
                    Icon(
                      Icons.photo_library,
                    ),
                    Container(
                      margin: EdgeInsets.only(left: 5.0),
                      child: Text(
                        S.of(context).gallery,
                      ),
                    ),
                  ],
                ),
                onPressed: () {
                  getPictureFromGallery(context, user, commentId: commentId, orderId: orderId);
                },
              ),
            ),
            Container(
              child: TextButton(
                child: Row(
                  mainAxisAlignment: MainAxisAlignment.start,
                  children: <Widget>[
                    Icon(
                      Icons.photo_camera,
                    ),
                    Container(
                      margin: EdgeInsets.only(left: 5.0),
                      child: Text(
                        S.of(context).camera,
                      ),
                    ),
                  ],
                ),
                onPressed: () {
                  getPictureFromCamera(context, user, commentId: commentId, orderId: orderId);
                },
              ),
            )
          ],
        ),
      ),
    );
  }

  void getPictureFromGallery(BuildContext context, User user, {int commentId = -1, int orderId = 0}) async {
    final picker = ImagePicker();
    var image = await picker.pickImage(source: ImageSource.gallery);
    Navigator.of(context).pop();
    uploadPicture(context, File(image.path), user, commentId: commentId, orderId: orderId);
  }

  void getPictureFromCamera(BuildContext context, User user, {int commentId = -1, int orderId = 0}) async {
    final picker = ImagePicker();
    var image = await picker.pickImage(source: ImageSource.camera);
    Navigator.of(context).pop();
    uploadPicture(context, File(image.path), user, commentId: commentId, orderId: orderId);
  }

  void uploadPicture(BuildContext context, File image, User user, {int commentId = -1, int orderId = 0}) async {
    if (await image.exists()) {
      print('image: ${image.path}');
      String imageName = basename(image.path);
      MultipartFile imageFile = await MultipartFile.fromFile(image.path, filename: imageName);
      Map<String, dynamic> formMap = {
        'id': user.id,
        'file': imageFile,
      };
      if (commentId >= 0) {
        formMap = {
          'contact_id': user.id,
          'comment_id': commentId,
          'order_id': orderId,
          'file': imageFile,
        };
        HttpUtil.httpPost(
          'v1/upload-comment-image',
              (response) {
            eventBus.fire(new OnCommentUpdatedEvent(Comment.fromJson(response.data)));
          },
          isFormData: true,
          body: formMap,
          sendProgress: (int sent, int total) {
            if (sent == total) {
              eventBus.fire(OnUploadCommentImageProgressEvent(false, 0.0));
            } else {
              eventBus.fire(OnUploadCommentImageProgressEvent(true, sent / total));
            }
          },
        ).catchError((error) {
          Utils.showMessageDialog(context, error);
        });
      } else {
        HttpUtil.httpPost(
          'v1/upload-avatar',
              (response) {
            store.dispatch(new UpdateCurrentUser(User.fromJson(response.data)));
            eventBus.fire(new OnCurrentUserUpdated());
          },
          isFormData: true,
          body: formMap,
          sendProgress: (int sent, int total) {
            if (sent == total) {
              eventBus.fire(OnProgressEvent(false, 0.0));
            } else {
              eventBus.fire(OnProgressEvent(true, sent / total));
            }
          },
        ).catchError((error) {
          Utils.showMessageDialog(context, error);
        });
      }
    }
  }

  AlertDialog getPicture2(BuildContext context, int imageId, OnGotFile onGotFile) {
    return AlertDialog(
      title: Text(
        S.of(context).get_picture,
      ),
      content: Container(
        height: 130.0,
        child: Column(
          children: <Widget>[
            Container(
              margin: EdgeInsets.only(bottom: 12.0),
              child: Text(
                S.of(context).get_picture_from,
                style: TextStyle(
                  fontSize: 15.0,
                  color: Colors.black26,
                ),
              ),
            ),
            Container(
              child: TextButton(
                child: Row(
                  mainAxisAlignment: MainAxisAlignment.start,
                  children: <Widget>[
                    Icon(
                      Icons.photo_library,
                    ),
                    Container(
                      margin: EdgeInsets.only(left: 5.0),
                      child: Text(
                        S.of(context).gallery,
                      ),
                    ),
                  ],
                ),
                onPressed: () {
                  getPictureFromGallery2(context, imageId, onGotFile);
                },
              ),
            ),
            Container(
              child: TextButton(
                child: Row(
                  mainAxisAlignment: MainAxisAlignment.start,
                  children: <Widget>[
                    Icon(
                      Icons.photo_camera,
                    ),
                    Container(
                      margin: EdgeInsets.only(left: 5.0),
                      child: Text(
                        S.of(context).camera,
                      ),
                    ),
                  ],
                ),
                onPressed: () {
                  getPictureFromCamera2(context, imageId, onGotFile);
                },
              ),
            )
          ],
        ),
      ),
    );
  }

  void getPictureFromGallery2(BuildContext context, int imageId, OnGotFile onGotFile) async {
    ImagePicker picker = ImagePicker();
    var image = await picker.pickImage(source: ImageSource.gallery);
    Navigator.of(context).pop();
    onGotFile(imageId, image.path);
  }

  void getPictureFromCamera2(BuildContext context, int imageId, OnGotFile onGotFile) async {
    ImagePicker picker = ImagePicker();
    var image = await picker.pickImage(source: ImageSource.camera);
    Navigator.of(context).pop();
    onGotFile(imageId, image.path);
  }

  Future<void> createTicket(BuildContext context, String msg, List<Map<String, dynamic>> images,
      OnSuccess onSuccess, OnError onError, {int id}) {
    var formData = FormData();
    formData.fields.add(MapEntry("msg", msg));
    formData.fields.add(MapEntry('id', id == null ? '0' : id.toString()));
    for (int i = 0; i < images.length; i++) {
      String imagePath = images[i]['path'];
      if (imagePath.isNotEmpty) {
        String imageName = basename(imagePath);
        formData.files.add(
          MapEntry(
            "files",
            MultipartFile.fromFileSync(imagePath, filename: imageName)
          )
        );
      }
    }
    HttpUtil.httpPost('create-new-ticket-app/', (response) {
      if (onSuccess != null) {
        onSuccess(response);
      }
    },
      isFormData: true,
      // body: null,
      formData: formData,
      sendProgress: (int sent, int total) {
        if (sent == total) {
          eventBus.fire(OnSubmitProgressEvent(false, 100.0));
        } else {
          eventBus.fire(OnSubmitProgressEvent(true, sent / total * 100.0));
        }
      },
      businessId: Constants.BUSINESS_ID,
    ).catchError((error) {
      if (onError != null) {
        onError(error);
      }
    });
  }

  Widget getNativePay(BuildContext context, Order order, PaymentPlatform paymentPlatform) {
    return GestureDetector(
      child: Container(
        padding: EdgeInsets.only(top: 16.0, left: 16.0, right: 16.0, bottom: 16.0),
        child: Center(
          child: Row(
            mainAxisAlignment: MainAxisAlignment.start,
            mainAxisSize: MainAxisSize.min,
            children: <Widget>[
              Container(
                margin: EdgeInsets.only(right: 6.0),
                child: Text(
                  Platform.isAndroid ? S.of(context).pay_with : S.of(context).pay_with,
                  style: TextStyle(
                    fontSize: 18.0,
                    fontWeight: FontWeight.bold,
                  ),
                ),
              ),
              Container(
                padding: EdgeInsets.only(right: 10.0),
                child: Platform.isAndroid ? Image.asset(
                  'assets/images/google_pay.png',
                  height: 22.0,
                  fit: BoxFit.fitHeight,
                ) : Image.asset(
                  'assets/images/apple_pay.png',
                  height: 22.0,
                  fit: BoxFit.fitHeight,
                ),
              ),
            ],
          ),
        ),
        decoration: BoxDecoration(
          border: Border(
            bottom: BorderSide(
              width: 10,
              color: Colors.black26,
            ),
          ),
        ),
      ),
      onTap: () {
        print(paymentPlatform);
        PaymentPlatform newPaymentPlatform = PaymentPlatform.fromJson(json.decode(json.encode(paymentPlatform)));
        newPaymentPlatform.code = Constants.PAYMENT_METHOD_NATIVE_PAY;
        goPayment(context, order, newPaymentPlatform);
      },
    );
  }

  static void goPayment(BuildContext context, Order order,
      PaymentPlatform paymentPlatform, {
        bool googlePay=false,
        bool applePay=false,
        StripePaymentMethod stripePaymentMethod,
      }) {
    switch(paymentPlatform.code) {
      case Constants.PAYMENT_METHOD_CODE_SQUARE:

        break;
      case Constants.PAYMENT_METHOD_CODE_CHASE:

        break;
      case Constants.PAYMENT_METHOD_CODE_PAYPAL:

        break;
      case Constants.PAYMENT_METHOD_CODE_OTT_ALIPAY:

        break;
      case Constants.PAYMENT_METHOD_CODE_OTT_WECHATPAY:

        break;
      case Constants.PAYMENT_METHOD_CODE_POD:

        break;
      case Constants.PAYMENT_METHOD_NATIVE_PAY:
        StripePayment.setOptions(
            StripeOptions(publishableKey: paymentPlatform.publishableKey,
                merchantId: paymentPlatform.merchantId,
                androidPayMode: paymentPlatform.publishableKey.contains('_test_')
                    ? 'test'
                    : 'production'
            )
        );
        StripePayment.paymentRequestWithNativePay(
          androidPayOptions: AndroidPayPaymentRequest(
            totalPrice: order.totalPrice.toStringAsFixed(2),
            currencyCode: order.businessInfo.currency,
          ),
          applePayOptions: ApplePayPaymentOptions(
            currencyCode: order.businessInfo.currency,
            countryCode: order.businessInfo.address.country,
            items: [
              ApplePayItem(
                label: order.businessInfo.name,
                amount: order.totalPrice.toStringAsFixed(2),
              ),
            ],
          ),
        ).then((token) {
          print('return native token: ${token.tokenId}');
          processNativePay(context, token, order);
        }).catchError((error) {
          print('native pay error: $error');
        });
        break;
      case Constants.PAYMENT_METHOD_CODE_STRIPE:
        Navigator.pushReplacement(context, MaterialPageRoute(
            builder: (BuildContext context) {
              return StripePay(order, paymentPlatform, stripePaymentMethod: stripePaymentMethod,);
            }
        ));
        break;
    }
  }

  static void processNativePay(BuildContext context, Token token, Order order) async {
    PaymentMethod paymentMethod = await StripePayment.createPaymentMethod(
      PaymentMethodRequest(
        card: CreditCard(
          token: token.tokenId,
        ),
      ),
    );
    if (paymentMethod != null) {
      Utils.stripePaymentIntent(order, null, paymentMethod.id, paymentMethod.type, (response) {
        if (response.data['status'] == Constants.STRIPE_STATUS_REQUIRES_CONFIRMATION) {
          StripePayment.confirmPaymentIntent(
            PaymentIntent(
              clientSecret: response.data[Constants.STRIPE_CLIENT_SECRET],
              paymentMethodId: response.data['payment_method'],
            ),
          ).then((paymentIntentResult) {
            if (paymentIntentResult.status == Constants.STRIPE_STATUS_SUCCEDED) {
              Utils.stripeChargedSuccess(order,
                  paymentMethod.id,
                  paymentIntentResult.paymentIntentId,
                      (response) {
                    StripePayment.completeNativePayRequest().then((_) {
                      eventBus.fire(OnOrderUpdated());
                      Routes.router.navigateTo(context, '/orderdetail/${order.id}', replace: true);
                    }).catchError((error) {
                      Utils.showMessageDialog(context, error, onOk: () {
                        Navigator.of(context).pop();
                      });
                    });
                  },
                      (error) {
                    Utils.showMessageDialog(context, error, onOk: () {
                      Navigator.of(context).pop();
                    });
                  }
              );
            } else {
              Utils.showMessageDialog(context, Exception('Unknown error'));
            }
          }).catchError((error) {
            Utils.showMessageDialog(context, error, onOk: () {
              Navigator.of(context).pop();
            });
          });
        }
      }, (error) {
        Utils.showMessageDialog(context, error, onOk: () {
          Navigator.of(context).pop();
        });
      });
    } else {

    }
  }

  static Future<Uint8List> getBytesFromAsset(String path, int width) async {
    ByteData data = await rootBundle.load(path);
    ui.Codec codec = await ui.instantiateImageCodec(data.buffer.asUint8List(), targetWidth: width);
    ui.FrameInfo fi = await codec.getNextFrame();
    return (await fi.image.toByteData(format: ui.ImageByteFormat.png)).buffer.asUint8List();
  }
}