import 'package:comunic/enums/user_page_visibility.dart';
import 'package:comunic/models/account_image_settings.dart';
import 'package:comunic/models/api_request.dart';
import 'package:comunic/models/data_conservation_policy_settings.dart';
import 'package:comunic/models/general_settings.dart';
import 'package:comunic/models/new_emoji.dart';
import 'package:comunic/models/security_settings.dart';
import 'package:image_picker/image_picker.dart';

/// Settings helper
///
/// @author Pierre Hubert

const _APIAccountImageVisibilityAPILevels = {
  "open": AccountImageVisibilityLevels.EVERYONE,
  "public": AccountImageVisibilityLevels.COMUNIC_USERS,
  "friends": AccountImageVisibilityLevels.FRIENDS_ONLY,
};

class SettingsHelper {
  /// Get & return general user settings
  static Future<GeneralSettings> getGeneralSettings() async {
    final response =
        (await APIRequest(uri: "settings/get_general", needLogin: true).exec())
            .assertOk()
            .getObject();

    return GeneralSettings(
      email: response["email"],
      firstName: response["firstName"],
      lastName: response["lastName"],
      pageVisibility: response["is_open"]
          ? UserPageVisibility.OPEN
          : response["is_public"]
              ? UserPageVisibility.PUBLIC
              : UserPageVisibility.PRIVATE,
      allowComments: response["allow_comments"],
      allowPostsFromFriends: response["allow_posts_from_friends"],
      allowComunicEmails: response["allow_comunic_mails"],
      publicFriendsList: response["public_friends_list"],
      virtualDirectory: response["virtual_directory"],
      personalWebsite: response["personnal_website"],
      publicNote: response["publicNote"],
    );
  }

  /// Apply new general settings
  static Future<void> updateGeneralSettings(GeneralSettings settings) async {
    (await APIRequest(uri: "settings/set_general", needLogin: true, args: {
      "firstName": settings.firstName,
      "lastName": settings.lastName,
      "allow_comunic_mails": settings.allowComunicEmails ? "true" : "false",
      "isPublic": settings.pageVisibility != UserPageVisibility.PRIVATE
          ? "true"
          : "false",
      "isOpen":
          settings.pageVisibility == UserPageVisibility.OPEN ? "true" : "false",
      "allowComments": settings.allowComments ? "true" : "false",
      "allowPostsFromFriends":
          settings.allowPostsFromFriends ? "true" : "false",
      "publicFriendsList": settings.publicFriendsList ? "true" : "false",
      "personnalWebsite": settings.personalWebsite,
      "virtualDirectory": settings.virtualDirectory,
      "publicNote": settings.publicNote,
    }).exec())
        .assertOk();
  }

  /// Check out whether a virtual directory is available for a user or not
  ///
  /// Throws in case of failure
  static Future<void> checkUserDirectoryAvailability(String dir) async =>
      (await APIRequest(
              uri: "settings/check_user_directory_availability",
              needLogin: true,
              args: {"directory": dir}).exec())
          .assertOk();

  /// Get & return account image settings
  static Future<AccountImageSettings> getAccountImageSettings() async {
    final response =
        (await APIRequest(uri: "settings/get_account_image", needLogin: true)
                .exec())
            .assertOk()
            .getObject();

    return AccountImageSettings(
        hasImage: response["has_image"],
        imageURL: response["image_url"],
        visibility:
            _APIAccountImageVisibilityAPILevels[response["visibility"]]);
  }

  /// Upload a new account image
  static Future<bool> uploadAccountImage(PickedFile newImage) async =>
      (await APIRequest(uri: "settings/upload_account_image", needLogin: true)
              .addPickedFile("picture", newImage)
              .execWithFiles())
          .isOK;

  /// Upload a new account image from memory
  static Future<bool> uploadAccountImageFromMemory(List<int> bytes) async =>
      (await APIRequest(uri: "settings/upload_account_image", needLogin: true)
              .addBytesFile("picture", BytesFile("accountImage.png", bytes))
              .execWithFiles())
          .isOK;

  /// Change account image visibility level
  static Future<bool> setAccountImageVisibilityLevel(
          AccountImageVisibilityLevels level) async =>
      (await APIRequest(
                  uri: "settings/set_account_image_visibility", needLogin: true)
              .addString(
                  "visibility",

                  // Find appropriate visibility level
                  _APIAccountImageVisibilityAPILevels.entries
                      .firstWhere((f) => f.value == level)
                      .key)
              .exec())
          .isOK;

  /// Delete user account image
  static Future<bool> deleteAccountImage() async =>
      (await APIRequest(uri: "settings/delete_account_image", needLogin: true)
              .exec())
          .isOK;

  /// Upload a new custom emoji
  static Future<void> uploadNewCustomEmoji(NewEmoji newEmoji) async =>
      (await APIRequest(
                  uri: "settings/upload_custom_emoji",
                  needLogin: true,
                  args: {"shortcut": newEmoji.shortcut})
              .addPickedFile("image", newEmoji.image)
              .execWithFiles())
          .assertOk();

  /// Delete a custom emoji
  ///
  /// Throws in case of failure
  static Future<void> deleteCustomEmoji(int emojiID) async =>
      (await APIRequest(uri: "settings/delete_custom_emoji", needLogin: true)
              .addInt("emojiID", emojiID)
              .exec())
          .assertOk();

  /// Check current user password
  ///
  /// Throws in case of failure
  static Future<void> checkUserPassword(String password) async =>
      await APIRequest(uri: "settings/check_password", needLogin: true)
          .addString("password", password)
          .execWithThrow();

  /// Change user password
  ///
  /// Throws in case of failure
  static Future<void> changePassword(
          String oldPassword, String newPassword) async =>
      await APIRequest(uri: "settings/update_password", needLogin: true)
          .addString("oldPassword", oldPassword)
          .addString("newPassword", newPassword)
          .execWithThrow();

  /// Retrieve security settings of the user
  ///
  /// This method throws in case of failure
  static Future<SecuritySettings> getSecuritySettings(String password) async {
    final response =
        (await APIRequest(uri: "settings/get_security", needLogin: true)
                .addString("password", password)
                .execWithThrow())
            .getObject();

    return SecuritySettings(
      securityQuestion1: response["security_question_1"],
      securityAnswer1: response["security_answer_1"],
      securityQuestion2: response["security_question_2"],
      securityAnswer2: response["security_answer_2"],
    );
  }

  /// Apply new security settings to the user
  ///
  /// Throws in case of failure
  static Future<void> setSecuritySettings(
      String password, SecuritySettings newSettings) async {
    await APIRequest(uri: "settings/set_security", needLogin: true)
        .addString("password", password)
        .addString("security_question_1", newSettings.securityQuestion1)
        .addString("security_answer_1", newSettings.securityAnswer1)
        .addString("security_question_2", newSettings.securityQuestion2)
        .addString("security_answer_2", newSettings.securityAnswer2)
        .execWithThrow();
  }

  /// Get account data conservation policy settings
  ///
  /// Throws in case of failure
  static Future<DataConservationPolicySettings>
      getDataConservationPolicy() async {
    final response =
        (await APIRequest.withLogin("settings/get_data_conservation_policy")
                .execWithThrow())
            .getObject();

    return DataConservationPolicySettings(
        inactiveAccountLifeTime: response["inactive_account_lifetime"],
        notificationLifetime: response["notification_lifetime"],
        commentsLifetime: response["comments_lifetime"],
        postsLifetime: response["posts_lifetime"],
        conversationMessagesLifetime:
            response["conversation_messages_lifetime"],
        likesLifetime: response["likes_lifetime"]);
  }

  /// Apply new data conservation policy settings
  ///
  /// Throws in case of failure
  static Future<void> setDataConservationPolicy(
      String password, DataConservationPolicySettings newSettings) async {
    await APIRequest(uri: "settings/set_data_conservation_policy", needLogin: true)
        .addString("password", password)
        .addInt("inactive_account_lifetime",
            newSettings.inactiveAccountLifeTime ?? 0)
        .addInt("notification_lifetime", newSettings.notificationLifetime ?? 0)
        .addInt("comments_lifetime", newSettings.commentsLifetime ?? 0)
        .addInt("posts_lifetime", newSettings.postsLifetime ?? 0)
        .addInt("conversation_messages_lifetime",
            newSettings.conversationMessagesLifetime ?? 0)
        .addInt("likes_lifetime", newSettings.likesLifetime ?? 0)
        .execWithThrow();
  }
}