import 'dart:io';
import 'package:flutter/material.dart';
import 'dart:convert';
import 'package:flutter/services.dart';
import 'package:http/http.dart' as http;
import 'package:fluttertoast/fluttertoast.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:intl/intl.dart';
import 'package:flutter_styled_toast/flutter_styled_toast.dart';
import 'dart:async';
import 'package:geolocator/geolocator.dart';
import 'package:watermanagement/preloader.dart';
import 'package:dio/dio.dart';

//const Color primaryColor = Color(0XFF0D4E84);
const Color primaryColor = Color(0XFF4D317D);
const Color secondaryColor = Color(0XFFDCCBFA);
const Color greyColor = Color(0XFF8F8E8E);
const Color textFieldStartColor = Colors.grey;
const Color screenBackgroundColor = Color(0XFFDCCBFA);
const Color screenBackgroundColord = Colors.black12;
const Color dashboardbackground = Color(0XFFF5F5F5);

Color AppBarGradient_1 = Color(0XFF4D317D);

TextStyle PreloaderText() {
  return TextStyle(color: Colors.blueAccent);
}
TextStyle labelTextStyle() {
  return TextStyle(color: primaryColor, fontSize: 12);
}
TextStyle textButtonStyle() {
  return TextStyle(color: primaryColor,fontSize: 15);
}
TextStyle iconBelowTextStyle() {
  return TextStyle(fontSize: 10,color: primaryColor);
}

TextStyle valuesTextStyle() {
  return TextStyle(fontSize: 12,fontWeight: FontWeight.bold,);
}
Text capacitySuffixText(){
  return Text('in Ltrs.');
}
TextStyle dashboardTextStyle() {
  return TextStyle(color: primaryColor, fontSize: 12,fontWeight: FontWeight.bold,);
}
TextStyle labelTextStyleBold() {
  return TextStyle(color: primaryColor, fontWeight: FontWeight.bold,);
}
TextStyle serverIssueTextStyle() {
  return TextStyle(color: Colors.red, fontSize: 15);
}

InputDecoration textFormFieldDecoration(IconData icon,var text){
  return InputDecoration(
    filled: true,
    fillColor: Colors.white,
    prefixIcon: Icon(
      icon,
      color: greyColor,
    ),
    border: OutlineInputBorder(borderSide: BorderSide(color: primaryColor)),
    focusedBorder: OutlineInputBorder(
      borderSide: BorderSide(color: primaryColor),
    ),
    enabledBorder: OutlineInputBorder(
      borderSide: BorderSide(color: primaryColor),
    ),
    labelText: text,
    labelStyle:
    TextStyle(color: primaryColor, fontWeight: FontWeight.bold //<-- SEE HERE
    ),
  );
}



class AppSettings {
  static SharedPreferences sharedPreferences = SharedPreferences.getInstance() as SharedPreferences;
  static String suppliername = '';
  static String email = '';
  static String phoneNumber = '';
  static String description = '';
  static String startingprice = '';
  static String accessToken = '';
  static String customerId = '';
  static String supplierId = '';
  static String customerIdsign = '';
  static List<String> storedPreferenceValidKeys = ['suppliername', 'access_token'];
  static String preloadText = 'Please wait';
  static String latitude='';
  static String longitude='';
  static String supplierAddress = '';
  static bool servicestatus = false;
  static bool haspermission = false;
  static late LocationPermission permission;
  static late Position position;
  static String long = "", lat = "";
  late StreamSubscription<Position> positionStream;
  static String fcmId='';
  static String serverToken='AAAArcCwMeU:APA91bEDVgDUWy7f7eIuTZDIkjNdzKHj2zA7pniMMjuCaXLRHry0aKEnMaGToxDtMKmEk4L3XWm9rwQ9MbbruUKAbzd_f1VZ72oe0u7Qqn5j1amXgxsvUkHNMUI1qXFGq6E1RbpkrG7a';

  //api urls
  static String host = 'http://35.207.198.4:3000/api/';

  static String loginUrl = host+'supplierlogin';
  static String signUpUrl = host+'suppliers';
  static String verifyPhnUrl = host+'supplierphone';
  static String resetTokenUrl = host+'reset_token';
  static String updateProfileUrl = host + 'update/currentSupplier';
  static String addTankerUrl = host + 'addTankers';
  static String getTankersDataUrl = host + 'getTankers';
  static String deleteTankerUrl = host + 'deleteTanker';
  static String UpdateTankerUrl = host + 'updateTankers';
  static String addDeliveryboyUrl = host + 'addDeliveryboys';
  static String getAllDeliverboyUrl = host + 'getalldeliveryboys';
  static String updateDeliveryboyUrl = host + 'updatedeliveryboy';
  static String deleteDeliveryboyUrl = host + 'deletedeliveryboy';
  static String pendingCustomersUrl = host + 'pendingCustomers';
  static String connectedCustomersUrl = host + 'connectedCustomers';
  static String bookingRequestsUrl = host + 'getAllTankersBookingdetails';
  static String acceptBookingRequestsUrl = host + 'ordernow';
  static String acceptRequestUrl = host +"friend-request/accept";
  static String rejectRequestUrl = host +"friend-request/reject";
  static String profilePicUrl = host + 'supplier/profile-picture';
  static String uploadPicUrl = host + 'uploads';











  static File? updatedImage;
  static String profilePictureUrl = '';

  static String image='';
  static var api = {
    'signIn': host + '/login',
  };

  /*Formatter*/
  static String formNum(String s) {
    var comma = NumberFormat('##,##,##,###');
    return  comma.format(
      int.parse(s),
    );
  }

  /* Preloader */
  static GlobalKey<State> preLoaderKey = new GlobalKey<State>();
  static Future<void> preLoaderDialog(BuildContext context) async {
    try {
      preLoaderKey = new GlobalKey<State>();
      Dialogs.showLoadingDialog(context, preLoaderKey);
    } catch (error) {}
  }


  static Future<String> uploadImageHTTPNew(file) async {

    var request = http.MultipartRequest('POST', Uri.parse(uploadPicUrl + '/' + supplierId));
    request.files.add(await http.MultipartFile.fromPath('picture', file.path));
    var res = await request.send();
    var response = await http.Response.fromStream(res);
    return response.body;

  }
  ////request headers with content type
  static Future<Map<String, String>> buildRequestHeaders() async {
    Map<String, String> _headers = new Map<String, String>();
    _headers[HttpHeaders.contentTypeHeader] = 'application/json';
    _headers['Authorization'] = accessToken;
    return _headers;
  }

  //request headers without content type
  static Future<Map<String, String>> buildPutRequestHeaders() async {
    Map<String, String> _headers = new Map<String, String>();
    _headers['Authorization'] = accessToken;
    return _headers;
  }
  static Future<Map<String, String>> buildPutRequestHeadersForResetToken() async {
    Map<String, String> _headers = new Map<String, String>();
    return _headers;
  }

  // Shared preferences save,get and clear data
  static saveData(String _key, _value, type) async {
    sharedPreferences = await SharedPreferences.getInstance();

    if (type == 'STRING') {
      await sharedPreferences.setString(_key, _value.toString());
    } else if (type == 'INTEGER') {
      await sharedPreferences.setInt(_key, _value);
    } else if (type == 'BOOL') {
      await sharedPreferences.setBool(_key, _value);
    } else if (type == 'DOUBLE') {
      await sharedPreferences.setDouble(_key, _value);
    }
  }

  static getData(String _key, type) async {
    sharedPreferences = await SharedPreferences.getInstance();
    if (type == 'STRING') {
      return sharedPreferences.getString(_key) ?? '';
    } else if (type == 'INTEGER') {
      return sharedPreferences.getInt(_key) ?? -1;
    } else if (type == 'BOOL') {
      return sharedPreferences.getBool(_key) ?? -1;
    } else if (type == 'DOUBLE') {
      return sharedPreferences.getDouble(_key) ?? -1;
    }
  }

  static clearSharedPreferences() async {
    sharedPreferences = await SharedPreferences.getInstance();
    await sharedPreferences.clear();
  }

  /*Sign in check*/
  static Future<bool> isSigIn() async {
    bool isSignInCheck = true;
    for (var eachKey in storedPreferenceValidKeys) {
      if (await getData(eachKey, 'STRING') == '') {
        isSignInCheck = false;
      }
    }
    return isSignInCheck;
  }


  static Future<bool> internetConnectivity() async {
    try {
      final result = await InternetAddress.lookup('google.com');
      if (result.isNotEmpty && result[0].rawAddress.isNotEmpty) {
        return true;
      }
    } on SocketException catch (_) {
      return false;
    }
    return false;
  }

  /*Apis Starts here*/

  static Future<bool> login(payload) async {

    var response = await http.post(Uri.parse(loginUrl),
        body: json.encode(payload),
        headers: {'Content-type': 'application/json'});



    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response['simplydata']['error']);

        if (_response['simplydata']['error'] == false) {
          await  saveAvailableReportAndLocationsInMemory(_response);
          return true;
        } else {
          return false;
        }
      } catch (e) {
        // display error toast
        return false;
      }
    } else {

      return false;

    }
  }

  static Future<bool> signUp(payload) async {
    var response = await http.post(Uri.parse(signUpUrl),
        body: json.encode(payload),
        headers: {'Content-type': 'application/json'});

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        // customerIdsign =_response['armintatankdata']['supplierId'];
        print(_response);
        return true;
      } catch (e) {
        // display error toast
        return false;
      }
    } else {
      return false;
    }
  }

  static Future<bool> verifyPhn(payload) async {
    var response = await http.post(Uri.parse(verifyPhnUrl),
        body: json.encode(payload),
        headers: {'Content-type': 'application/json'});

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        if (_response['armintatankdata']['error'] == false) {
          return true;
        } else {
          return false;
        }
      } catch (e) {
        // display error toast
        return false;
      }
    } else {
      return false;
    }
  }

  static Future<bool> resetToken() async {
    var uri = Uri.parse(resetTokenUrl+ '/' + customerId);

    try {
      // var response = await http.get(uri, headers: await buildPutRequestHeaders());
      var response  = await http.get(uri, headers: await buildPutRequestHeadersForResetToken());
      if (response.statusCode == 200) {
        print(response.body);
        var res=jsonDecode(response.body);
        print(res);

        accessToken=res['access_token'];
        return true;
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }

  static Future<bool> updateProfile(payload) async {
    try {
      var response = await http.put(
          Uri.parse(updateProfileUrl + '/' + supplierId),
          body: json.encode(payload),
          headers: await buildRequestHeaders());

      if (response.statusCode == 200) {
        var _response = json.decode(response.body);

        suppliername = _response['suppliername'];
        phoneNumber = _response['phone'];
        email = _response['emails'][0]['email'];
        description = _response['description'];
        startingprice = _response['startingPrice'];


        return true;
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }

  static Future<bool> updateProfilePicture(payload) async {
    var uri = Uri.parse(profilePicUrl + '/' + supplierId);
    var response = await http.post(uri,
        body: json.encode(payload), headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return true;
      } catch (e) {
        // display error toast
        return false;
      }
    } else {
      return false;
    }
  }


  static Future<bool> addTankers(payload) async {
    var response = await http.post(Uri.parse(addTankerUrl + '/' + supplierId),
        body: json.encode(payload), headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return true;
      } catch (e) {
        // display error toast
        return false;
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.post(Uri.parse(addTankerUrl + '/' + supplierId),
            body: json.encode(payload), headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return true;
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      return false;
    }
  }
  static Future<String> getTankers() async {
    //query parameter
    var uri = Uri.parse(getTankersDataUrl);
    uri = uri.replace(query: 'supplierId=$supplierId');

    var response = await http.get(uri, headers: await buildRequestHeaders());
    if (response.statusCode == 200) {
      return response.body;
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.get(uri, headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return response.body;
        } else {
          return '';
        }
      } else {
        return '';
      }
    } else {
      return '';
    }
  }
  static Future<bool> updateTanker(tankerName, payload) async {
    var uri = Uri.parse(UpdateTankerUrl + '/' + supplierId);
    uri = uri.replace(query: 'tankerName=$tankerName');

    try {
      var response = await http.put(uri,
          body: json.encode(payload), headers: await buildRequestHeaders());

      if (response.statusCode == 200) {
        return true;
      } else if (response.statusCode == 401) {
        bool status = await AppSettings.resetToken();
        if (status) {
          response = await http.put(uri,
              body: json.encode(payload), headers: await buildRequestHeaders());
          if (response.statusCode == 200) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }
  static Future<bool> deleteTanker(tankerName) async {
    var uri = Uri.parse(deleteTankerUrl + '/' + supplierId);
    uri = uri.replace(query: 'tankerName=$tankerName');

    try {
      var response =
      await http.put(uri, headers: await buildPutRequestHeaders());

      if (response.statusCode == 200) {
        return true;
      } else if (response.statusCode == 401) {
        bool status = await AppSettings.resetToken();
        if (status) {
          response =
          await http.put(uri, headers: await buildPutRequestHeaders());
          if (response.statusCode == 200) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }


  static Future<bool> addDeliverboy(payload) async {
    var response = await http.post(Uri.parse(addDeliveryboyUrl + '/' + supplierId),
        body: json.encode(payload), headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return true;
      } catch (e) {
        // display error toast
        return false;
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.post(Uri.parse(addDeliveryboyUrl + '/' + supplierId),
            body: json.encode(payload), headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return true;
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      return false;
    }
  }
  static Future<String> getAllDeliverboy() async {
    var response = await http.get(Uri.parse(getAllDeliverboyUrl + '/' + supplierId),
        headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return response.body;
      } catch (e) {
        // display error toast
        return '';
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.get(Uri.parse(getAllDeliverboyUrl + '/' + supplierId),
            headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return response.body;
        } else {
          return "";
        }
      } else {
        return "";
      }
    } else {
      return "";
    }
  }
  static Future<bool> updateDeliveryboy(phone, payload) async {
    var uri = Uri.parse(updateDeliveryboyUrl + '/' + supplierId);
    uri = uri.replace(query: 'phone=$phone');

    try {
      var response = await http.put(uri,
          body: json.encode(payload), headers: await buildRequestHeaders());

      if (response.statusCode == 200) {
        return true;
      } else if (response.statusCode == 401) {
        bool status = await AppSettings.resetToken();
        if (status) {
          response = await http.put(uri,
              body: json.encode(payload), headers: await buildRequestHeaders());
          if (response.statusCode == 200) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }
  static Future<bool> deleteDeliveryboy(phone) async {
    var uri = Uri.parse(deleteDeliveryboyUrl + '/' + supplierId);
    uri = uri.replace(query: 'phone=$phone');

    try {
      var response =
      await http.put(uri, headers: await buildPutRequestHeaders());

      if (response.statusCode == 200) {
        return true;
      } else if (response.statusCode == 401) {
        bool status = await AppSettings.resetToken();
        if (status) {
          response =
          await http.put(uri, headers: await buildPutRequestHeaders());
          if (response.statusCode == 200) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }


  static Future<String> getPendingSuppliers() async {
    var response = await http.get(Uri.parse(pendingCustomersUrl + '/' + supplierId),
        headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return response.body;
      } catch (e) {
        // display error toast
        return '';
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.get(Uri.parse(pendingCustomersUrl + '/' + supplierId),
            headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return response.body;
        } else {
          return "";
        }
      } else {
        return "";
      }
    } else {
      return "";
    }
  }
  static Future<String> getConnectedCustomers() async {
    var response = await http.get(Uri.parse(connectedCustomersUrl + '/' + supplierId),
        headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return response.body;
      } catch (e) {
        // display error toast
        return '';
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.get(Uri.parse(connectedCustomersUrl + '/' + supplierId),
            headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return response.body;
        } else {
          return "";
        }
      } else {
        return "";
      }
    } else {
      return "";
    }
  }

  static Future<String> getBookingRequests() async {
    var response = await http.get(Uri.parse(bookingRequestsUrl + '/' + supplierId),
        headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return response.body;
      } catch (e) {
        // display error toast
        return '';
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.get(Uri.parse(bookingRequestsUrl + '/' + supplierId),
            headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return response.body;
        } else {
          return "";
        }
      } else {
        return "";
      }
    } else {
      return "";
    }
  }

  static Future<bool> acceptBookingRequests(var bookingId,payload) async {
    var response = await http.post(Uri.parse(acceptBookingRequestsUrl + '/' + bookingId),
        body: json.encode(payload), headers: await buildRequestHeaders());

    if (response.statusCode == 200) {
      try {
        var _response = json.decode(response.body);
        print(_response);
        return true;
      } catch (e) {
        // display error toast
        return false;
      }
    } else if (response.statusCode == 401) {
      bool status = await AppSettings.resetToken();
      if (status) {
        response = await http.post(Uri.parse(acceptBookingRequestsUrl + '/' + bookingId),
            body: json.encode(payload), headers: await buildRequestHeaders());
        if (response.statusCode == 200) {
          return true;
        } else {
          return false;
        }
      } else {
        return false;
      }
    } else {
      return false;
    }
  }


  static Future<bool> acceptRequest( payload) async {
    var uri = Uri.parse(acceptRequestUrl );
    try {
      var response = await http.put(uri,
          body: json.encode(payload), headers: await buildRequestHeaders());

      if (response.statusCode == 200) {
        return true;
      } else if (response.statusCode == 401) {
        bool status = await AppSettings.resetToken();
        if (status) {
          response = await http.put(uri,
              body: json.encode(payload), headers: await buildRequestHeaders());
          if (response.statusCode == 200) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }
  static Future<bool> rejectRequest( payload) async {
    var uri = Uri.parse(rejectRequestUrl );
    try {
      var response = await http.put(uri,
          body: json.encode(payload), headers: await buildRequestHeaders());

      if (response.statusCode == 200) {
        return true;
      } else if (response.statusCode == 401) {
        bool status = await AppSettings.resetToken();
        if (status) {
          response = await http.put(uri,
              body: json.encode(payload), headers: await buildRequestHeaders());
          if (response.statusCode == 200) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      } else {
        return false;
      }
    } catch (e) {
      print(e);
      return false;
    }
  }


  static Future<void> sendNotification(var body,var titile)async{
    final postUrl = 'https://fcm.googleapis.com/fcm/send';
    var token = fcmId;
    print('token : $token');

    final data = {
      "notification": {"body":body, "title": titile},
      "priority": "high",
      "data": {
        "click_action": "FLUTTER_NOTIFICATION_CLICK",
        "id": "1",
        "status": "done"
      },
      "to": "$token"
    };

    final headers = {
      'content-type': 'application/json',
      'Authorization': 'key=$serverToken',
    };


    BaseOptions options = BaseOptions(
      headers: headers,
    );


    try {
      final response = await Dio(options).post(postUrl,
          data: data);

      if (response.statusCode == 200) {
        longSuccessToast('Request notification sent to supplier');
      } else {
        print('notification sending failed');
        // on failure do sth
      }
    }
    catch(e){
      print('exception $e');
    }




  }

  static Future<void> sendNotificationFromApp(var body,var titile)async{
    http.post(
      Uri.parse('https://fcm.googleapis.com/fcm/send' ),
      headers: <String, String>{
        'Content-Type': 'application/json',
        'Authorization': 'key=$serverToken',
      },
      body: jsonEncode(
        <String, dynamic>{
          'notification': <String, dynamic>{
            'title': titile,
            'body': body,

          },
          'priority': 'high',
          'data': <String, dynamic>{
            'click_action': 'FLUTTER_NOTIFICATION_CLICK',
            'id': '1',
            'status': 'done'
          },
          'to': fcmId,
        },
      ),
    );
  }





  /*Apis ends here*/


  //save data local
  static Future<void> saveAvailableReportAndLocationsInMemory(dynamic input) async {
    // save login name information
    await saveData('suppliername', input['simplydata']['suppliername'], 'STRING');
    await saveData('access_token', input['simplydata']['access_token'], 'STRING');
    await saveData('phone', input['simplydata']['phone'], 'STRING');
    await saveData('email', input['simplydata']['email'][0]['email'], 'STRING');
    await saveData('supplierId', input['simplydata']['supplierId'], 'STRING');
    await saveData('profile', input['simplydata']['picture'], 'STRING');
    await saveData('supplieraddress', input['simplydata']['office_address'], 'STRING');

    await loadDataFromMemory();
  }
  static Future<void> saveProfile(dynamic image) async {
    // save login name information
    await saveData('profile', image.toString(), 'STRING');
    //await loadDataFromMemory();
  }

  static Future<void> loadDataFromMemory() async {
    suppliername = await getData('suppliername', 'STRING');
    accessToken = await getData('access_token', 'STRING');
    email=await getData('email', 'STRING');
    phoneNumber=await getData('phone', 'STRING');
    supplierId=await getData('supplierId', 'STRING');
    profilePictureUrl=await getData('profile', 'STRING');
    supplierAddress=await getData('supplieraddress', 'STRING');
  }

  //assign saved values to variables
  static Future<void> getProfile() async {

    final image1 = await getData('profile', 'STRING');
    //Io.File.fromUri(imageFile.uri)
    if (image1 == null) return;

    if(image1==''){
      updatedImage=null;
    }
    else{
      final imageTemp =File(image1);
      updatedImage=imageTemp;
    }

    print(updatedImage);
  }

  static Widget noDataUI(String _tabName) {
    _tabName = _tabName ?? '';
    return Container(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: <Widget>[
          Image(
            image: AssetImage('images/no_data.png'),
            width: 200,
          ),
          SizedBox(
            height: 8,
          ),
          Text(
            'There is no data to show you right now.',
            style: TextStyle(
              fontSize: 12,
              color: Colors.grey[600],
              fontFamily: 'Swis2',
            ),
          ),
          SizedBox(
            height: 5,
          ),
          Text(
            _tabName,
            style: TextStyle(fontSize: 15, fontFamily: 'Swis1'),
          ),
        ],
      ),
    );
  }

  static  appBar(String title) {
    title = title ?? '';
    return AppBar(
      backgroundColor: primaryColor,
      title:  Text(title),
    );
  }

  static void longFailedToast(String message) {
    Fluttertoast.showToast(
        msg: message,
        toastLength: Toast.LENGTH_LONG,
        gravity: ToastGravity.BOTTOM,
        timeInSecForIosWeb: 1,
        backgroundColor: Colors.red,
        textColor: Colors.white,
        fontSize: 16.0);
  }

  static void longFailedStyledToast(String message,context) {
    showToast(message,
      context: context,
      animation: StyledToastAnimation.scale,
      reverseAnimation: StyledToastAnimation.fade,
      position: StyledToastPosition.bottom,
      animDuration: Duration(seconds: 1),
      duration: Duration(seconds: 6),
      curve: Curves.elasticOut,
      reverseCurve: Curves.linear,
      backgroundColor: Colors.red,
    );
  }

  static void longSuccessToast(String message) {
    Fluttertoast.showToast(
        msg: message,
        toastLength: Toast.LENGTH_SHORT,
        gravity: ToastGravity.BOTTOM,

        timeInSecForIosWeb: 1,
        backgroundColor: Colors.green,
        textColor: Colors.white,
        fontSize: 16.0
    );
  }


  /*location*/
  static checkGps() async {
    servicestatus = await Geolocator.isLocationServiceEnabled();
    if(servicestatus){
      permission = await Geolocator.checkPermission();

      if (permission == LocationPermission.denied) {
        permission = await Geolocator.requestPermission();
        if (permission == LocationPermission.denied) {
          print('Location permissions are denied');
        }else if(permission == LocationPermission.deniedForever){
          print("'Location permissions are permanently denied");
        }else{
          haspermission = true;
        }
      }else{
        haspermission = true;
      }

      if(haspermission){
        /*setState(() {
          //refresh the UI
        });*/

        await getLocation();
      }
    }
    else{
      print("GPS Service is not enabled, turn on GPS location");
    }

  }

  static  getLocation() async {
    position = await Geolocator.getCurrentPosition(desiredAccuracy: LocationAccuracy.high);
    /*print(position.longitude); //Output: 80.24599079
    print(position.latitude);*/ //Output: 29.6593457

    long = await position.longitude.toString();
    lat = await position.latitude.toString();

    /*setState(() {
      //refresh UI
    });*/

    LocationSettings locationSettings = LocationSettings(
      accuracy: LocationAccuracy.high, //accuracy of the location data
      distanceFilter: 100, //minimum distance (measured in meters) a
      //device must move horizontally before an update event is generated;
    );

    StreamSubscription<Position> positionStream = Geolocator.getPositionStream(
        locationSettings: locationSettings).listen((Position position) {
      print(position.longitude); //Output: 80.24599079
      print(position.latitude); //Output: 29.6593457

      long = position.longitude.toString();
      lat = position.latitude.toString();

      /*setState(() {
        //refresh UI on update
      });*/
    });
  }

}