package app.fedilab.android.client;
/* Copyright 2017 Thomas Schneider
 *
 * This file is a part of Fedilab
 *
 * This program is free software; you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation; either version 3 of the
 * License, or (at your option) any later version.
 *
 * Fedilab is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
 * Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with Fedilab; if not,
 * see <http://www.gnu.org/licenses>. */

import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.sqlite.SQLiteDatabase;
import android.os.Build;
import android.os.Bundle;
import android.text.Html;
import android.text.SpannableString;

import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import androidx.preference.PreferenceManager;


import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.lang.ref.WeakReference;
import java.net.URLEncoder;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import app.fedilab.android.R;
import app.fedilab.android.activities.MainActivity;
import app.fedilab.android.asynctasks.UpdateAccountInfoAsyncTask;
import app.fedilab.android.client.Entities.Account;
import app.fedilab.android.client.Entities.AccountAdmin;
import app.fedilab.android.client.Entities.AccountCreation;
import app.fedilab.android.client.Entities.AdminAction;
import app.fedilab.android.client.Entities.Announcement;
import app.fedilab.android.client.Entities.Application;
import app.fedilab.android.client.Entities.Attachment;
import app.fedilab.android.client.Entities.Card;
import app.fedilab.android.client.Entities.Conversation;
import app.fedilab.android.client.Entities.Emojis;
import app.fedilab.android.client.Entities.Error;
import app.fedilab.android.client.Entities.Filters;
import app.fedilab.android.client.Entities.HowToVideo;
import app.fedilab.android.client.Entities.IdentityProof;
import app.fedilab.android.client.Entities.Instance;
import app.fedilab.android.client.Entities.InstanceNodeInfo;
import app.fedilab.android.client.Entities.InstanceReg;
import app.fedilab.android.client.Entities.InstanceSocial;
import app.fedilab.android.client.Entities.Mention;
import app.fedilab.android.client.Entities.NodeInfo;
import app.fedilab.android.client.Entities.Notification;
import app.fedilab.android.client.Entities.Peertube;
import app.fedilab.android.client.Entities.Poll;
import app.fedilab.android.client.Entities.PollOptions;
import app.fedilab.android.client.Entities.PushSubscription;
import app.fedilab.android.client.Entities.Reaction;
import app.fedilab.android.client.Entities.Relationship;
import app.fedilab.android.client.Entities.Report;
import app.fedilab.android.client.Entities.Results;
import app.fedilab.android.client.Entities.Schedule;
import app.fedilab.android.client.Entities.Status;
import app.fedilab.android.client.Entities.StoredStatus;
import app.fedilab.android.client.Entities.Tag;
import app.fedilab.android.client.Entities.Trends;
import app.fedilab.android.client.Entities.TrendsHistory;
import app.fedilab.android.fragments.DisplayNotificationsFragment;
import app.fedilab.android.helper.ECDH;
import app.fedilab.android.helper.Helper;
import app.fedilab.android.sqlite.AccountDAO;
import app.fedilab.android.sqlite.Sqlite;
import app.fedilab.android.sqlite.TimelineCacheDAO;

import static app.fedilab.android.helper.ECDH.kp_private;
import static app.fedilab.android.helper.ECDH.kp_public;
import static app.fedilab.android.helper.ECDH.newPair;


/**
 * Created by Thomas on 23/04/2017.
 * Manage Calls to the REST API
 * Modify the 16/11/2017 with httpsurlconnection
 */

public class API {


    private Account account;
    private final Context context;
    private Results results;
    private Attachment attachment;
    private List<Account> accounts;
    private List<Status> statuses;
    private int tootPerPage, accountPerPage, notificationPerPage;
    private int actionCode;
    private String instance;
    private String prefKeyOauthTokenT;
    private APIResponse apiResponse;
    private Error APIError;
    private List<String> domains;

    public API(Context context) {
        this.context = context;
        if (context == null) {
            APIError = new Error();
            return;
        }
        SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        tootPerPage = sharedpreferences.getInt(Helper.SET_TOOT_PER_PAGE, Helper.TOOTS_PER_PAGE);
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED && tootPerPage > 20) {
            tootPerPage = 20;
        }
        accountPerPage = Helper.ACCOUNTS_PER_PAGE;
        notificationPerPage = Helper.NOTIFICATIONS_PER_PAGE;
        this.prefKeyOauthTokenT = sharedpreferences.getString(Helper.PREF_KEY_OAUTH_TOKEN, null);
        if (Helper.getLiveInstance(context) != null)
            this.instance = Helper.getLiveInstance(context);
        else {
            SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
            String userId = sharedpreferences.getString(Helper.PREF_KEY_ID, null);
            String instance = sharedpreferences.getString(Helper.PREF_INSTANCE, Helper.getLiveInstance(context));
            Account account = new AccountDAO(context, db).getUniqAccount(userId, instance);
            if (account == null) {
                APIError = new Error();
                APIError.setError(context.getString(R.string.toast_error));
                return;
            }
            this.instance = account.getInstance().trim();
        }
        apiResponse = new APIResponse();
        APIError = null;
    }

    public API(Context context, String instance, String token) {
        this.context = context;
        if (context == null) {
            apiResponse = new APIResponse();
            APIError = new Error();
            return;
        }
        SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        tootPerPage = sharedpreferences.getInt(Helper.SET_TOOT_PER_PAGE, Helper.TOOTS_PER_PAGE);
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED && tootPerPage > 20) {
            tootPerPage = 20;
        }
        accountPerPage = Helper.ACCOUNTS_PER_PAGE;
        notificationPerPage = Helper.NOTIFICATIONS_PER_PAGE;
        if (instance != null)
            this.instance = instance;
        else
            this.instance = Helper.getLiveInstance(context);

        if (token != null)
            this.prefKeyOauthTokenT = token;
        else
            this.prefKeyOauthTokenT = sharedpreferences.getString(Helper.PREF_KEY_OAUTH_TOKEN, null);
        apiResponse = new APIResponse();
        APIError = null;
    }

    /**
     * Parse json response an unique Car
     *
     * @param resobj JSONObject
     * @return Card
     */
    private static Card parseCardResponse(JSONObject resobj) {

        Card card = new Card();
        try {
            card.setUrl(resobj.getString("url"));
            card.setTitle(resobj.getString("title"));
            card.setDescription(resobj.getString("description"));
            card.setImage(resobj.getString("image"));

            card.setType(resobj.getString("type"));
            try {
                card.setAuthor_name(resobj.getString("author_name"));
            } catch (Exception e) {
                card.setAuthor_name(null);
            }
            try {
                card.setAuthor_url(resobj.getString("author_url"));
            } catch (Exception e) {
                card.setAuthor_url(null);
            }
            try {
                card.setHtml(resobj.getString("html"));
            } catch (Exception e) {
                card.setHtml(null);
            }
            try {
                card.setEmbed_url(resobj.getString("embed_url"));
            } catch (Exception e) {
                card.setEmbed_url(null);
            }
            try {
                card.setProvider_name(resobj.getString("provider_name"));
            } catch (Exception e) {
                card.setProvider_name(null);
            }
            try {
                card.setProvider_url(resobj.getString("provider_url"));
            } catch (Exception e) {
                card.setProvider_url(null);
            }
            try {
                card.setHeight(resobj.getInt("height"));
            } catch (Exception e) {
                card.setHeight(0);
            }
            try {
                card.setWidth(resobj.getInt("width"));
            } catch (Exception e) {
                card.setWidth(0);
            }
        } catch (JSONException e) {
            card = null;
        }
        return card;
    }

    /**
     * Parse json response an unique instance social result
     *
     * @param resobj JSONObject
     * @return InstanceSocial
     */
    public static InstanceSocial parseInstanceSocialResponse(JSONObject resobj) {

        InstanceSocial instanceSocial = new InstanceSocial();
        try {


            instanceSocial.setUptime(Float.parseFloat(resobj.getString("uptime")));
            instanceSocial.setUp(resobj.getBoolean("up"));

            instanceSocial.setConnections(Long.parseLong(resobj.getString("connections")));
            instanceSocial.setDead(resobj.getBoolean("dead"));


            instanceSocial.setId(resobj.getString("id"));

            instanceSocial.setInfo(resobj.getString("info"));
            instanceSocial.setVersion(resobj.getString("version"));
            instanceSocial.setName(resobj.getString("name"));
            instanceSocial.setObs_rank(resobj.getString("obs_rank"));
            instanceSocial.setThumbnail(resobj.getString("thumbnail"));
            instanceSocial.setIpv6(resobj.getBoolean("ipv6"));
            instanceSocial.setObs_score(resobj.getInt("obs_score"));
            instanceSocial.setOpen_registrations(resobj.getBoolean("open_registrations"));

            instanceSocial.setUsers(Long.parseLong(resobj.getString("users")));
            instanceSocial.setStatuses(Long.parseLong(resobj.getString("statuses")));

            instanceSocial.setHttps_rank(resobj.getString("https_rank"));
            instanceSocial.setHttps_score(resobj.getInt("https_score"));
            if (!resobj.isNull("added_at")) {
                instanceSocial.setAdded_at(Helper.mstStringToDate(resobj.getString("added_at")));
            }
            instanceSocial.setChecked_at(Helper.mstStringToDate(resobj.getString("checked_at")));
            instanceSocial.setUpdated_at(Helper.mstStringToDate(resobj.getString("updated_at")));


        } catch (Exception e) {
            e.printStackTrace();
        }
        return instanceSocial;
    }

    /**
     * Parse json response for unique how to
     *
     * @param resobj JSONObject
     * @return Peertube
     */
    public static Peertube parsePeertube(String instance, JSONObject resobj) {
        Peertube peertube = new Peertube();
        try {
            peertube.setId(resobj.getString("id"));
            peertube.setCache(resobj);
            peertube.setUuid(resobj.getString("uuid"));
            peertube.setName(resobj.getString("name"));
            peertube.setDescription(resobj.getString("description"));
            peertube.setEmbedPath(resobj.getString("embedPath"));
            peertube.setPreviewPath(resobj.getString("previewPath"));
            peertube.setThumbnailPath(resobj.getString("thumbnailPath"));
            peertube.setAccount(parseAccountResponsePeertube(instance, resobj.getJSONObject("account")));
            peertube.setInstance(instance);
            peertube.setView(resobj.getInt("views"));
            peertube.setLike(resobj.getInt("likes"));
            peertube.setDislike(resobj.getInt("dislikes"));
            peertube.setDuration(resobj.getInt("duration"));
            try {
                peertube.setCreated_at(Helper.mstStringToDate(resobj.getString("createdAt")));
            } catch (ParseException e) {
                e.printStackTrace();
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }

        return peertube;
    }

    /**
     * Parse json response for unique how to
     *
     * @param resobj JSONObject
     * @return Peertube
     */
    private static Peertube parseSinglePeertube(String instance, JSONObject resobj) {
        Peertube peertube = new Peertube();
        try {
            peertube.setId(resobj.getString("id"));
            peertube.setUuid(resobj.getString("uuid"));
            peertube.setName(resobj.getString("name"));
            peertube.setCache(resobj);
            peertube.setInstance(instance);
            peertube.setHost(resobj.getJSONObject("account").getString("host"));
            peertube.setDescription(resobj.getString("description"));
            peertube.setEmbedPath(resobj.getString("embedPath"));
            peertube.setPreviewPath(resobj.getString("previewPath"));
            peertube.setThumbnailPath(resobj.getString("thumbnailPath"));
            peertube.setView(resobj.getInt("views"));
            peertube.setLike(resobj.getInt("likes"));
            peertube.setCommentsEnabled(resobj.getBoolean("commentsEnabled"));
            peertube.setDislike(resobj.getInt("dislikes"));
            peertube.setDuration(resobj.getInt("duration"));
            peertube.setAccount(parseAccountResponsePeertube(instance, resobj.getJSONObject("account")));
            try {
                peertube.setCreated_at(Helper.mstStringToDate(resobj.getString("createdAt")));
            } catch (ParseException e) {
                e.printStackTrace();
            }

            ArrayList<String> resolutions = new ArrayList<>();
            if (resobj.has("streamingPlaylists") && resobj.getJSONArray("streamingPlaylists").length() > 0) {
                JSONArray files = resobj.getJSONArray("streamingPlaylists").getJSONObject(0).getJSONArray("files");

                for (int j = 0; j < files.length(); j++) {
                    JSONObject attObj = files.getJSONObject(j);
                    resolutions.add(attObj.getJSONObject("resolution").getString("id"));
                }
                peertube.setResolution(resolutions);
                peertube.setStreamService(true);
            } else {
                JSONArray files = resobj.getJSONArray("files");

                for (int j = 0; j < files.length(); j++) {
                    JSONObject attObj = files.getJSONObject(j);
                    resolutions.add(attObj.getJSONObject("resolution").getString("id"));
                }
                peertube.setResolution(resolutions);
                peertube.setStreamService(false);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }

        return peertube;
    }

    /**
     * Parse json response for peertube comments
     *
     * @param resobj JSONObject
     * @return Peertube
     */
    private static List<Status> parseSinglePeertubeComments(Context context, String instance, JSONObject resobj) {
        List<Status> statuses = new ArrayList<>();
        try {
            JSONArray jsonArray = resobj.getJSONArray("data");
            int i = 0;
            while (i < jsonArray.length()) {
                Status status = new Status();
                JSONObject comment = jsonArray.getJSONObject(i);
                status.setId(comment.getString("id"));
                status.setUri(comment.getString("url"));
                status.setUrl(comment.getString("url"));
                status.setSensitive(false);
                status.setSpoiler_text("");
                status.setContent(context, comment.getString("text"));
                status.setIn_reply_to_id(comment.getString("inReplyToCommentId"));
                status.setAccount(parseAccountResponsePeertube(instance, comment.getJSONObject("account")));
                status.setCreated_at(Helper.mstStringToDate(comment.getString("createdAt")));
                status.setMentions(new ArrayList<>());
                status.setEmojis(new ArrayList<>());
                status.setMedia_attachments(new ArrayList<>());
                status.setVisibility("public");
                status.setViewType(context);
                SpannableString spannableString;
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
                    spannableString = new SpannableString(Html.fromHtml(status.getContent(), Html.FROM_HTML_MODE_LEGACY));
                else
                    spannableString = new SpannableString(Html.fromHtml(status.getContent()));
                status.setContentSpan(new SpannableString(spannableString));
                i++;
                statuses.add(status);
            }
        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        return statuses;
    }

    /**
     * Parse json response for unique how to
     *
     * @param resobj JSONObject
     * @return HowToVideo
     */
    private static HowToVideo parseHowTo(JSONObject resobj) {
        HowToVideo howToVideo = new HowToVideo();
        try {
            howToVideo.setId(resobj.getString("id"));
            howToVideo.setUuid(resobj.getString("uuid"));
            howToVideo.setName(resobj.getString("name"));
            howToVideo.setDescription(resobj.getString("description"));
            howToVideo.setEmbedPath(resobj.getString("embedPath"));
            howToVideo.setPreviewPath(resobj.getString("previewPath"));
            howToVideo.setThumbnailPath(resobj.getString("thumbnailPath"));
        } catch (JSONException e) {
            e.printStackTrace();
        }

        return howToVideo;
    }

    /**
     * Parse json response for several scheduled toots
     *
     * @param jsonObject JSONObject
     * @return List<Status>
     */
    private static Schedule parseSimpleSchedule(Context context, JSONObject jsonObject) {
        Schedule schedule = new Schedule();
        try {
            JSONObject resobj = jsonObject.getJSONObject("params");
            Status status = parseSchedule(context, resobj);
            List<Attachment> attachements = parseAttachmentResponse(jsonObject.getJSONArray("media_attachments"));
            status.setMedia_attachments((ArrayList<Attachment>) attachements);
            schedule.setStatus(status);
            schedule.setAttachmentList(attachements);
            schedule.setId(jsonObject.getString("id"));
            schedule.setScheduled_at(Helper.mstStringToDate(jsonObject.getString("scheduled_at")));
        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        return schedule;
    }

    /**
     * Parse json response for several scheduled toots
     *
     * @param jsonArray JSONArray
     * @return List<Status>
     */
    private static List<Schedule> parseSchedule(Context context, JSONArray jsonArray) {

        List<Schedule> schedules = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                Schedule schedule = new Schedule();
                JSONObject resobj = jsonArray.getJSONObject(i).getJSONObject("params");
                Status status = parseSchedule(context, resobj);
                List<Attachment> attachements = parseAttachmentResponse(jsonArray.getJSONObject(i).getJSONArray("media_attachments"));
                status.setMedia_attachments((ArrayList<Attachment>) attachements);
                schedule.setStatus(status);
                schedule.setAttachmentList(attachements);
                schedules.add(schedule);
                schedule.setId(jsonArray.getJSONObject(i).getString("id"));
                schedule.setScheduled_at(Helper.mstStringToDate(jsonArray.getJSONObject(i).getString("scheduled_at")));
                i++;
            }
        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        return schedules;
    }

    /**
     * Parse json response for several status
     *
     * @param jsonArray JSONArray
     * @return List<Status>
     */
    private static List<Status> parseStatuses(Context context, JSONArray jsonArray) {

        List<Status> statuses = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Status status = parseStatuses(context, resobj);
                i++;
                statuses.add(status);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return statuses;
    }

    /**
     * Parse json response for several reactions
     *
     * @param jsonArray JSONArray
     * @return List<Reaction>
     */
    private static List<Reaction> parseReaction(JSONArray jsonArray) {
        List<Reaction> reactions = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Reaction reaction = parseReaction(resobj);
                i++;
                reactions.add(reaction);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return reactions;
    }


    /**
     * Parse a push notification
     *
     * @param resobj JSONObject
     * @return PushSubscription
     */
    private static PushSubscription parsePushNotifications(JSONObject resobj) {
        PushSubscription pushSubscription = new PushSubscription();
        try {
            pushSubscription.setId(resobj.getString("id"));
            pushSubscription.setEndpoint(resobj.getString("endpoint"));
            pushSubscription.setServer_key(resobj.getString("server_key"));
            JSONObject alertsObject = resobj.getJSONObject("alerts");
            Iterator<String> iter = alertsObject.keys();
            HashMap<String, Boolean> alertsList = new HashMap<>();
            while (iter.hasNext()) {
                String key = iter.next();
                boolean value = (boolean) alertsObject.get(key);
                alertsList.put(key, value);
            }
            pushSubscription.setAlertsList(alertsList);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return pushSubscription;
    }

    /**
     * Parse a reaction
     *
     * @param resobj JSONObject
     * @return Reaction
     */
    private static Reaction parseReaction(JSONObject resobj) {
        Reaction reaction = new Reaction();
        try {
            reaction.setName(resobj.getString("name"));
            reaction.setCount(resobj.getInt("count"));
            reaction.setMe(resobj.getBoolean("me"));
            if (resobj.has("url")) {
                reaction.setUrl(resobj.getString("url"));
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return reaction;
    }

    /**
     * Parse json response for several announcements
     *
     * @param jsonArray JSONArray
     * @return List<Announcement>
     */
    private static List<Announcement> parseAnnouncement(Context context, JSONArray jsonArray) {

        List<Announcement> announcements = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Announcement announcement = parseAnnouncement(context, resobj);
                i++;
                announcements.add(announcement);
            }

        } catch (JSONException e) {
            e.printStackTrace();
        }
        return announcements;
    }

    /**
     * Parse an annoucement
     *
     * @param context Context
     * @param resobj  JSONObject
     * @return Announcement
     */
    private static Announcement parseAnnouncement(Context context, JSONObject resobj) {
        Announcement announcement = new Announcement();
        try {
            Account account = new Account();
            account.setBot(false);
            account.setUsername("admin");
            account.setUuid("admin");
            account.setId("admin");
            account.setDisplay_name("admin");
            announcement.setMedia_attachments(new ArrayList<>());
            announcement.setAccount(account);
            announcement.setId(resobj.getString("id"));
            announcement.setContent(context, resobj.getString("content"));
            if (resobj.getString("published_at").compareTo("null") != 0) {
                announcement.setCreated_at(Helper.mstStringToDate(resobj.getString("published_at")));
            }
            if (resobj.getString("updated_at").compareTo("null") != 0) {
                announcement.setUpdatedAt(Helper.mstStringToDate(resobj.getString("updated_at")));
            }
            if (resobj.getString("starts_at").compareTo("null") != 0) {
                announcement.setStartAt(Helper.mstStringToDate(resobj.getString("starts_at")));
            }
            if (resobj.getString("ends_at").compareTo("null") != 0) {
                announcement.setEndAt(Helper.mstStringToDate(resobj.getString("ends_at")));
            }


            announcement.setRead(resobj.getBoolean("read"));

            announcement.setReactions(parseReaction(resobj.getJSONArray("reactions")));


            List<Tag> tags = new ArrayList<>();
            JSONArray arrayTag = resobj.getJSONArray("tags");
            for (int j = 0; j < arrayTag.length(); j++) {
                JSONObject tagObj = arrayTag.getJSONObject(j);
                Tag tag = new Tag();
                tag.setName(tagObj.getString("name"));
                tag.setUrl(tagObj.getString("url"));
                tags.add(tag);
            }
            announcement.setTags(tags);

            List<Emojis> emojiList = new ArrayList<>();
            try {
                JSONArray emojisTag = resobj.getJSONArray("emojis");
                for (int j = 0; j < emojisTag.length(); j++) {
                    JSONObject emojisObj = emojisTag.getJSONObject(j);
                    Emojis emojis = parseEmojis(emojisObj);
                    emojiList.add(emojis);
                }
                announcement.setEmojis(emojiList);
            } catch (Exception e) {
                announcement.setEmojis(new ArrayList<>());
            }

            List<Mention> mentions = new ArrayList<>();

            try {
                JSONArray arrayMention = resobj.getJSONArray("mentions");
                for (int j = 0; j < arrayMention.length(); j++) {
                    JSONObject menObj = arrayMention.getJSONObject(j);
                    Mention mention = new Mention();
                    mention.setId(menObj.getString("id"));
                    mention.setUrl(menObj.getString("url"));
                    mention.setAcct(menObj.getString("acct"));
                    mention.setUsername(menObj.getString("username"));
                    mentions.add(mention);
                }
                announcement.setMentions(mentions);
            } catch (Exception e) {
                announcement.setMentions(new ArrayList<>());
            }

        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        Status.fillSpan(new WeakReference<>(context), announcement);
        return announcement;
    }

    /**
     * Parse a poll
     *
     * @param resobj JSONObject
     * @return Poll
     */
    private static Poll parsePoll(JSONObject resobj) {
        Poll poll = new Poll();
        try {
            poll.setId(resobj.getString("id"));
            poll.setExpires_at(Helper.mstStringToDate(resobj.getString("expires_at")));
            poll.setExpired(resobj.getBoolean("expired"));
            poll.setMultiple(resobj.getBoolean("multiple"));
            poll.setVotes_count(resobj.getInt("votes_count"));
            if (resobj.has("voters_count")) {
                poll.setVoters_count(resobj.getInt("voters_count"));
            } else {
                poll.setVoters_count(resobj.getInt("votes_count"));
            }
            List<Emojis> emojiList = new ArrayList<>();
            try {
                JSONArray emojisPoll = resobj.getJSONArray("emojis");
                for (int j = 0; j < emojisPoll.length(); j++) {
                    JSONObject emojisObj = emojisPoll.getJSONObject(j);
                    Emojis emojis = parseEmojis(emojisObj);
                    emojiList.add(emojis);
                }
                poll.setEmojis(emojiList);
            } catch (Exception e) {
                poll.setEmojis(new ArrayList<>());
            }
            poll.setVoted(resobj.getBoolean("voted"));
            JSONArray options = resobj.getJSONArray("options");
            List<PollOptions> pollOptions = new ArrayList<>();
            for (int i = 0; i < options.length(); i++) {
                JSONObject option = options.getJSONObject(i);
                PollOptions pollOption = new PollOptions();
                pollOption.setTitle(option.getString("title"));
                pollOption.setVotes_count(option.getInt("votes_count"));
                pollOptions.add(pollOption);
            }
            poll.setOptionsList(pollOptions);
            JSONArray own_votes = resobj.getJSONArray("own_votes");
            List<Integer> own_votes_list = new ArrayList<>();
            for (int i = 0; i < own_votes.length(); i++) {
                int own_vote = own_votes.getInt(i);
                own_votes_list.add(own_vote);
            }
            poll.setOwn_votes(own_votes_list);
        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        return poll;
    }


    /**
     * Parse json response for unique status
     *
     * @param resobj JSONObject
     * @return Status
     */
    public static Status parseStatuses(Context context, JSONObject resobj) {
        return parseStatuses(context, resobj, true);
    }

    /**
     * Parse json response for unique status
     *
     * @param context   Context
     * @param resobj    JSONObject
     * @param recursive boolean
     * @return Status
     */
    private static Status parseStatuses(Context context, JSONObject resobj, boolean recursive) {
        Status status = new Status();
        try {
            status.setId(resobj.getString("id"));
            if (resobj.has("uri")) {
                status.setUri(resobj.getString("uri"));
            } else {
                status.setUri(resobj.getString("id"));
            }
            if (resobj.has("created_at")) {
                status.setCreated_at(Helper.mstStringToDate(resobj.getString("created_at")));
            } else {
                status.setCreated_at(new Date());
            }

            if (!resobj.isNull("in_reply_to_id")) {
                status.setIn_reply_to_id(resobj.getString("in_reply_to_id"));
            }
            if (!resobj.isNull("in_reply_to_account_id")) {
                status.setIn_reply_to_account_id(resobj.getString("in_reply_to_account_id"));
            }
            if (resobj.has("sensitive")) {
                status.setSensitive(resobj.getBoolean("sensitive"));
            } else {
                status.setSensitive(false);
            }
            if (resobj.has("spoiler_text")) {
                status.setSpoiler_text(resobj.getString("spoiler_text"));
            }
            try {
                status.setVisibility(resobj.getString("visibility"));
            } catch (Exception e) {
                status.setVisibility("public");
            }
            try {
                status.setLanguage(resobj.getString("language"));
            } catch (Exception e) {
                status.setLanguage("ja");
            }

            List<Reaction> reactions = new ArrayList<>();
            if (resobj.has("pleroma") && resobj.getJSONObject("pleroma").has("emoji_reactions")) {
                try {
                    reactions = parseReaction(resobj.getJSONObject("pleroma").getJSONArray("emoji_reactions"));
                } catch (Exception ignored) {
                }
            }
            status.setReactions(reactions);

            if (resobj.has("url")) {
                status.setUrl(resobj.getString("url"));
            }
            ArrayList<Attachment> attachments = new ArrayList<>();
            //Retrieves attachments
            if (resobj.has("media_attachments")) {
                JSONArray arrayAttachement = resobj.getJSONArray("media_attachments");

                for (int j = 0; j < arrayAttachement.length(); j++) {
                    JSONObject attObj = arrayAttachement.getJSONObject(j);
                    Attachment attachment = new Attachment();
                    attachment.setId(attObj.getString("id"));
                    attachment.setPreview_url(attObj.getString("preview_url"));
                    attachment.setRemote_url(attObj.getString("remote_url"));
                    attachment.setType(attObj.getString("type"));
                    attachment.setText_url(attObj.getString("text_url"));
                    attachment.setUrl(attObj.getString("url"));
                    try {
                        attachment.setDescription(attObj.getString("description"));
                    } catch (JSONException ignore) {
                    }
                    attachments.add(attachment);
                }
            }
            try {
                status.setCard(parseCardResponse(resobj.getJSONObject("card")));
            } catch (Exception e) {
                status.setCard(null);
            }

            status.setMedia_attachments(attachments);
            //Retrieves mentions
            List<Mention> mentions = new ArrayList<>();
            if (resobj.has("mentions")) {
                JSONArray arrayMention = resobj.getJSONArray("mentions");
                for (int j = 0; j < arrayMention.length(); j++) {
                    JSONObject menObj = arrayMention.getJSONObject(j);
                    Mention mention = new Mention();
                    mention.setId(menObj.getString("id"));
                    mention.setUrl(menObj.getString("url"));
                    mention.setAcct(menObj.getString("acct"));
                    mention.setUsername(menObj.getString("username"));
                    mentions.add(mention);
                }
            }
            status.setMentions(mentions);
            //Retrieves tags
            List<Tag> tags = new ArrayList<>();
            if (resobj.has("tags")) {
                JSONArray arrayTag = resobj.getJSONArray("tags");
                for (int j = 0; j < arrayTag.length(); j++) {
                    JSONObject tagObj = arrayTag.getJSONObject(j);
                    Tag tag = new Tag();
                    tag.setName(tagObj.getString("name"));
                    tag.setUrl(tagObj.getString("url"));
                    tags.add(tag);
                }
            }
            status.setTags(tags);
            //Retrieves emjis
            List<Emojis> emojiList = new ArrayList<>();
            if (resobj.has("emojis")) {
                try {
                    JSONArray emojisTag = resobj.getJSONArray("emojis");
                    for (int j = 0; j < emojisTag.length(); j++) {
                        JSONObject emojisObj = emojisTag.getJSONObject(j);
                        Emojis emojis = parseEmojis(emojisObj);
                        emojiList.add(emojis);
                    }
                } catch (Exception ignored) {
                }
            }
            status.setEmojis(emojiList);
            //Retrieve Application
            Application application = new Application();
            try {
                resobj.getJSONObject("application");
                application.setName(resobj.getJSONObject("application").getString("name"));
                application.setWebsite(resobj.getJSONObject("application").getString("website"));
            } catch (Exception e) {
                application = new Application();
            }
            status.setApplication(application);

            status.setAccount(parseAccountResponse(resobj.getJSONObject("account")));
            status.setContent(context, resobj.getString("content"));
            if (!resobj.isNull("favourites_count")) {
                status.setFavourites_count(resobj.getInt("favourites_count"));
            } else {
                status.setFavourites_count(0);
            }
            if (!resobj.isNull("reblogs_count")) {
                status.setReblogs_count(resobj.getInt("reblogs_count"));
            } else {
                status.setReblogs_count(0);
            }

            try {
                status.setReplies_count(resobj.getInt("replies_count"));
            } catch (Exception e) {
                status.setReplies_count(-1);
            }
            try {
                status.setReblogged(resobj.getBoolean("reblogged"));
            } catch (Exception e) {
                status.setReblogged(false);
            }
            try {
                status.setFavourited(resobj.getBoolean("favourited"));
            } catch (Exception e) {
                status.setFavourited(false);
            }
            try {
                status.setMuted(resobj.getBoolean("muted"));
            } catch (Exception e) {
                status.setMuted(false);
            }
            try {
                status.setPinned(resobj.getBoolean("pinned"));
            } catch (JSONException e) {
                status.setPinned(false);
            }
            try {
                if (recursive) {
                    status.setReblog(parseStatuses(context, resobj.getJSONObject("reblog"), false));
                }
            } catch (Exception ignored) {
            }

            if (resobj.has("poll") && !resobj.isNull("poll")) {
                Poll poll = parsePoll(resobj.getJSONObject("poll"));
                status.setPoll(poll);
            }

        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        status.setViewType(context);
        Status.fillSpan(new WeakReference<>(context), status);
        return status;
    }

    /**
     * Parse json response for unique schedule
     *
     * @param resobj JSONObject
     * @return Status
     */
    private static Status parseSchedule(Context context, JSONObject resobj) {
        Status status = new Status();
        try {
            status.setIn_reply_to_id(resobj.getString("in_reply_to_id"));
            if (!resobj.isNull("sensitive")) {
                status.setSensitive(resobj.getBoolean("sensitive"));
            } else {
                status.setSensitive(false);
            }
            status.setSpoiler_text(resobj.getString("spoiler_text"));
            try {
                status.setVisibility(resobj.getString("visibility"));
            } catch (Exception e) {
                status.setVisibility("public");
            }
            status.setContent(context, resobj.getString("text"));
        } catch (JSONException ignored) {
        }
        return status;
    }

    /**
     * Parse json response for several notes (Misskey)
     *
     * @param jsonArray JSONArray
     * @return List<Status>
     */
    private static List<Status> parseNotes(Context context, String instance, JSONArray jsonArray) {

        List<Status> statuses = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Status status = parseNotes(context, instance, resobj);
                i++;
                statuses.add(status);
            }

        } catch (JSONException e) {
            e.printStackTrace();
        }
        return statuses;
    }

    /**
     * Parse json response for unique note (misskey)
     *
     * @param resobj JSONObject
     * @return Status
     */
    private static Status parseNotes(Context context, String instance, JSONObject resobj) {
        Status status = new Status();
        try {

            status.setId(resobj.getString("id"));
            status.setUri("https://" + instance + "/notes/" + resobj.getString("id"));
            status.setCreated_at(Helper.mstStringToDate(resobj.getString("createdAt")));
            status.setIn_reply_to_id(resobj.getString("replyId"));
            status.setSensitive(false);
            resobj.get("cw");
            if (!resobj.getString("cw").equals("null"))
                status.setSpoiler_text(resobj.getString("cw"));
            try {
                status.setVisibility(resobj.getString("visibility"));
            } catch (Exception e) {
                status.setVisibility("public");
                e.printStackTrace();
            }
            status.setUrl("https://" + instance + "/notes/" + resobj.getString("id"));
            //Retrieves attachments
            if (resobj.has("media")) {
                JSONArray arrayAttachement = resobj.getJSONArray("media");
                ArrayList<Attachment> attachments = new ArrayList<>();
                for (int j = 0; j < arrayAttachement.length(); j++) {
                    JSONObject attObj = arrayAttachement.getJSONObject(j);
                    Attachment attachment = new Attachment();
                    attachment.setId(attObj.getString("id"));
                    attachment.setPreview_url(attObj.getString("thumbnailUrl"));
                    attachment.setRemote_url(attObj.getString("url"));
                    if (attObj.getString("type").contains("/")) {
                        attachment.setType(attObj.getString("type").split("/")[0]);
                    } else
                        attachment.setType(attObj.getString("type"));
                    attachment.setText_url(attObj.getString("url"));
                    attachment.setUrl(attObj.getString("url"));
                    if (attObj.getString("isSensitive").equals("true")) {
                        status.setSensitive(true);
                    }
                    try {
                        attachment.setDescription(attObj.getString("comment"));
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    attachments.add(attachment);
                }
                status.setMedia_attachments(attachments);
            } else {
                status.setMedia_attachments(new ArrayList<>());
            }
            try {
                status.setCard(parseCardResponse(resobj.getJSONObject("card")));
            } catch (Exception e) {
                status.setCard(null);
            }


            //Retrieves mentions
            List<Mention> mentions = new ArrayList<>();

            status.setAccount(parseMisskeyAccountResponse(instance, resobj.getJSONObject("user")));

            status.setContent(context, resobj.getString("text"));
            try {
                status.setReplies_count(resobj.getInt("repliesCount"));
            } catch (Exception e) {
                status.setReplies_count(-1);
            }
            try {
                status.setFavourited(resobj.getBoolean("isFavorited"));
            } catch (Exception e) {
                status.setFavourited(false);
            }
            status.setBookmarked(resobj.has("bookmarked") && !resobj.isNull("bookmarked"));
            try {
                resobj.getJSONObject("renoteId");
                if (!resobj.getJSONObject("renoteId").toString().equals("null"))
                    status.setReblog(parseStatuses(context, resobj.getJSONObject("renote")));
            } catch (Exception ignored) {
            }

            status.setMentions(mentions);
            //Retrieves tags
            List<Tag> tags = new ArrayList<>();
            if (resobj.has("tags")) {
                JSONArray arrayTag = resobj.getJSONArray("tags");
                for (int j = 0; j < arrayTag.length(); j++) {
                    JSONObject tagObj = arrayTag.getJSONObject(j);
                    Tag tag = new Tag();
                    tag.setName(tagObj.getString("name"));
                    tag.setUrl(tagObj.getString("url"));
                    tags.add(tag);
                }
            }
            status.setTags(tags);

            //Retrieves emjis
            List<Emojis> emojiList = new ArrayList<>();
            if (resobj.has("emojis")) {
                JSONArray emojisTag = resobj.getJSONArray("emojis");
                for (int j = 0; j < emojisTag.length(); j++) {
                    JSONObject emojisObj = emojisTag.getJSONObject(j);
                    Emojis emojis = parseMisskeyEmojis(emojisObj);
                    emojiList.add(emojis);
                }
                status.setEmojis(emojiList);
            }
            status.setEmojis(emojiList);
            //Retrieve Application
            Application application = new Application();
            try {
                resobj.getJSONObject("application");
                application.setName(resobj.getJSONObject("application").getString("name"));
                application.setWebsite(resobj.getJSONObject("application").getString("website"));
            } catch (Exception e) {
                application = new Application();
            }
            status.setApplication(application);


        } catch (JSONException ignored) {
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Status.fillSpan(new WeakReference<>(context), status);
        return status;
    }

    /**
     * Parse json response for emoji
     *
     * @param resobj JSONObject
     * @return Emojis
     */
    private static Emojis parseEmojis(JSONObject resobj) {
        Emojis emojis = new Emojis();
        try {
            emojis.setShortcode(resobj.getString("shortcode"));
            emojis.setStatic_url(resobj.getString("static_url"));
            emojis.setUrl(resobj.getString("url"));
            try {
                emojis.setVisible_in_picker((resobj.getBoolean("visible_in_picker")));
            } catch (Exception e) {
                emojis.setVisible_in_picker(true);
            }
        } catch (Exception ignored) {
        }
        return emojis;
    }

    /**
     * Parse json response for emoji
     *
     * @param resobj JSONObject
     * @return Emojis
     */
    private static Emojis parseMisskeyEmojis(JSONObject resobj) {
        Emojis emojis = new Emojis();
        try {
            emojis.setShortcode(resobj.getString("name"));
            emojis.setStatic_url(resobj.getString("url"));
            emojis.setUrl(resobj.getString("url"));
        } catch (Exception ignored) {
        }
        return emojis;
    }

    /**
     * Parse json response for emoji
     *
     * @param resobj JSONObject
     * @return Emojis
     */
    private static app.fedilab.android.client.Entities.List parseList(JSONObject resobj) {
        app.fedilab.android.client.Entities.List list = new app.fedilab.android.client.Entities.List();
        try {
            list.setId(resobj.getString("id"));
            list.setTitle(resobj.getString("title"));
        } catch (Exception ignored) {
        }
        return list;
    }

    /**
     * Parse json response an unique peertube account
     *
     * @param resobj JSONObject
     * @return Account
     */
    private static Account parseAccountResponsePeertube(String instance, JSONObject resobj) {
        Account account = new Account();
        try {
            account.setId(resobj.getString("id"));
            account.setUsername(resobj.getString("name"));
            account.setAcct(resobj.getString("name") + "@" + resobj.getString("host"));
            account.setDisplay_name(resobj.getString("displayName"));
            account.setHost(resobj.getString("host"));
            if (resobj.has("createdAt"))
                account.setCreated_at(Helper.mstStringToDate(resobj.getString("createdAt")));
            else
                account.setCreated_at(new Date());

            if (resobj.has("followersCount"))
                account.setFollowers_count(resobj.getInt("followersCount"));
            else
                account.setFollowers_count(0);
            if (resobj.has("followingCount"))
                account.setFollowing_count(resobj.getInt("followingCount"));
            else
                account.setFollowing_count(0);
            account.setStatuses_count(0);
            if (resobj.has("description"))
                account.setNote(resobj.getString("description"));
            else
                account.setNote("");
            account.setUrl(resobj.getString("url"));
            account.setSocial("PEERTUBE");
            if (resobj.has("avatar") && !resobj.getString("avatar").equals("null")) {
                account.setAvatar("https://" + instance + resobj.getJSONObject("avatar").get("path"));
                account.setAvatar_static("https://" + instance + resobj.getJSONObject("avatar").get("path"));
            } else
                account.setAvatar(null);
            account.setAvatar_static(resobj.getString("avatar"));
        } catch (JSONException ignored) {
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return account;
    }

    /**
     * Parse json response an unique report for admins
     *
     * @param resobj JSONObject
     * @return AccountAdmin
     */
    private static Report parseReportAdminResponse(Context context, JSONObject resobj) {

        Report report = new Report();
        try {
            report.setId(resobj.getString("id"));
            if (!resobj.isNull("action_taken")) {
                report.setAction_taken(resobj.getBoolean("action_taken"));
            } else if (!resobj.isNull("state")) {
                report.setAction_taken(!resobj.getString("state").equals("open"));
            }
            if (!resobj.isNull("comment")) {
                report.setComment(resobj.getString("comment"));
            } else if (!resobj.isNull("content")) {
                report.setComment(resobj.getString("content"));
            }


            report.setCreated_at(Helper.mstStringToDate(resobj.getString("created_at")));
            if (!resobj.isNull("updated_at")) {
                report.setUpdated_at(Helper.mstStringToDate(resobj.getString("updated_at")));
            }
            if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                if (!resobj.isNull("account")) {
                    report.setAccount(parseAccountAdminResponse(resobj.getJSONObject("account")));
                }
                if (!resobj.isNull("target_account")) {
                    report.setTarget_account(parseAccountAdminResponse(resobj.getJSONObject("target_account")));
                }
                if (!resobj.isNull("assigned_account")) {
                    report.setAssigned_account(parseAccountAdminResponse(resobj.getJSONObject("assigned_account")));
                }
            } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {

                if (!resobj.isNull("account")) {
                    Account account = parseAccountResponse(resobj.getJSONObject("account"));
                    AccountAdmin accountAdmin = new AccountAdmin();
                    accountAdmin.setId(account.getId());
                    accountAdmin.setUsername(account.getAcct());
                    accountAdmin.setAccount(account);
                    report.setTarget_account(accountAdmin);
                }

                if (!resobj.isNull("actor")) {
                    Account account = parseAccountResponse(resobj.getJSONObject("actor"));
                    AccountAdmin accountAdmin = new AccountAdmin();
                    accountAdmin.setId(account.getId());
                    accountAdmin.setUsername(account.getAcct());
                    accountAdmin.setAccount(account);
                    report.setAccount(accountAdmin);
                }

            }

            if (!resobj.isNull("action_taken_by_account")) {
                report.setAction_taken_by_account(parseAccountAdminResponse(resobj.getJSONObject("action_taken_by_account")));
            }
            report.setStatuses(parseStatuses(context, resobj.getJSONArray("statuses")));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return report;
    }

    /**
     * Parse json response an unique account for admins
     *
     * @param resobj JSONObject
     * @return Account
     */
    private static AccountAdmin parseAccountAdminResponse(JSONObject resobj) {

        AccountAdmin accountAdmin = new AccountAdmin();
        try {
            accountAdmin.setId(resobj.getString("id"));
            if (!resobj.isNull("username")) {
                accountAdmin.setUsername(resobj.getString("username"));
            }
            if (!resobj.isNull("nickname")) {
                accountAdmin.setUsername(resobj.getString("nickname"));
            }
            if (!resobj.isNull("created_at")) {
                accountAdmin.setCreated_at(Helper.mstStringToDate(resobj.getString("created_at")));
            }
            if (!resobj.isNull("email")) {
                accountAdmin.setEmail(resobj.getString("email"));
            }
            if (!resobj.isNull("role")) {
                accountAdmin.setRole(resobj.getString("role"));
            }
            if (!resobj.isNull("roles")) {
                if (resobj.getJSONObject("roles").getBoolean("admin")) {
                    accountAdmin.setRole("admin");
                } else if (resobj.getJSONObject("roles").getBoolean("moderator")) {
                    accountAdmin.setRole("moderator");
                } else {
                    accountAdmin.setRole("user");
                }
            }
            if (!resobj.isNull("ip")) {
                accountAdmin.setIp(resobj.getString("ip"));
            }
            if (!resobj.isNull("domain")) {
                accountAdmin.setDomain(resobj.getString("domain"));
            }

            if (!resobj.isNull("account")) {
                accountAdmin.setAccount(parseAccountResponse(resobj.getJSONObject("account")));
            } else {
                Account account = new Account();
                account.setId(accountAdmin.getId());
                account.setAcct(accountAdmin.getUsername());
                account.setDisplay_name(accountAdmin.getUsername());
                accountAdmin.setAccount(account);
            }
            if (!resobj.isNull("confirmed")) {
                accountAdmin.setConfirmed(resobj.getBoolean("confirmed"));
            } else {
                accountAdmin.setConfirmed(true);
            }
            if (!resobj.isNull("suspended")) {
                accountAdmin.setSuspended(resobj.getBoolean("suspended"));
            } else {
                accountAdmin.setSuspended(false);
            }
            if (!resobj.isNull("silenced")) {
                accountAdmin.setSilenced(resobj.getBoolean("silenced"));
            } else {
                accountAdmin.setSilenced(false);
            }
            if (!resobj.isNull("disabled")) {
                accountAdmin.setDisabled(resobj.getBoolean("disabled"));
            } else {
                if (!resobj.isNull("deactivated")) {
                    accountAdmin.setDisabled(resobj.getBoolean("deactivated"));
                } else {
                    accountAdmin.setDisabled(false);
                }
            }

            if (!resobj.isNull("approved")) {
                accountAdmin.setApproved(resobj.getBoolean("approved"));
            } else {
                accountAdmin.setApproved(true);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return accountAdmin;
    }


    /**
     * Parse json response an unique account
     *
     * @param resobj JSONObject
     * @return Account
     */
    private static Account parseAccountResponse(JSONObject resobj) {
        return parseAccountResponse(resobj, true);
    }


    /**
     * Parse json response an unique account
     *
     * @param resobj JSONObject
     * @return Account
     */
    private static Account parseAccountPixelfedSearchResponse(JSONObject resobj) {

        Account account = new Account();
        try {
            account.setId(resobj.getJSONObject("entity").getString("id"));
            account.setFollowing(resobj.getJSONObject("entity").getBoolean("following"));
            account.setAvatar(resobj.getString("avatar"));
            account.setAvatar_static(resobj.getString("avatar"));
            account.setDisplay_name(resobj.getString("name"));
            account.setUsername(resobj.getString("value"));
            account.setNote("");
            account.setAcct(resobj.getString("value"));
            account.setUrl(resobj.getString("url"));
            account.setStatuses_count(resobj.getJSONObject("entity").getInt("post_count"));
        } catch (Exception ignored) {
        }
        return account;
    }

    /**
     * Parse json response an unique account
     *
     * @param resobj    JSONObject
     * @param recursive boolean
     * @return Account
     */
    private static Account parseAccountResponse(JSONObject resobj, boolean recursive) {

        Account account = new Account();
        try {
            account.setId(resobj.getString("id"));
            account.setUuid(resobj.getString("id"));
            account.setUsername(resobj.getString("username"));
            account.setAcct(resobj.getString("acct"));
            account.setDisplay_name(resobj.getString("display_name"));
            if (account.getDisplay_name() == null || account.getDisplay_name().compareTo("") == 0) {
                account.setDisplay_name(resobj.getString("username"));
            }
            account.setLocked(resobj.getBoolean("locked"));
            if (resobj.has("created_at") && !resobj.isNull("created_at")) {
                account.setCreated_at(Helper.mstStringToDate(resobj.getString("created_at")));
            } else {
                account.setCreated_at(new Date());
            }
            if (!resobj.isNull("followers_count")) {
                account.setFollowers_count(resobj.getInt("followers_count"));
            } else {
                account.setFollowers_count(0);
            }
            if (!resobj.isNull("following_count")) {
                account.setFollowing_count(resobj.getInt("following_count"));
            } else {
                account.setFollowing_count(0);
            }
            if (!resobj.isNull("statuses_count")) {
                account.setStatuses_count(resobj.getInt("statuses_count"));
            } else {
                account.setStatuses_count(0);
            }
            account.setNote(resobj.getString("note"));
            try {
                account.setBot(resobj.getBoolean("bot"));
            } catch (Exception e) {
                account.setBot(false);
            }
            try {
                if (recursive) {
                    account.setMoved_to_account(parseAccountResponse(resobj.getJSONObject("moved"), false));
                }
            } catch (Exception ignored) {
                account.setMoved_to_account(null);
            }
            account.setUrl(resobj.getString("url"));
            account.setAvatar(resobj.getString("avatar"));
            if (resobj.has("avatar_static"))
                account.setAvatar_static(resobj.getString("avatar_static"));
            else
                account.setAvatar_static(resobj.getString("avatar"));
            if (resobj.has("header"))
                account.setHeader(resobj.getString("header"));
            if (resobj.has("header_static"))
                account.setHeader_static(resobj.getString("header_static"));
            try {
                if (resobj.has("pleroma")) {
                    account.setSocial("PLEROMA");
                    try {
                        account.setModerator(resobj.getJSONObject("pleroma").getBoolean("is_moderator"));
                        account.setAdmin(resobj.getJSONObject("pleroma").getBoolean("is_admin"));
                    } catch (Exception ignored) {
                        account.setModerator(false);
                        account.setAdmin(false);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            try {
                if (resobj.has("fields") && resobj.get("fields") instanceof JSONArray) {
                    JSONArray fields = resobj.getJSONArray("fields");
                    LinkedHashMap<String, String> fieldsMap = new LinkedHashMap<>();
                    LinkedHashMap<String, Boolean> fieldsMapVerified = new LinkedHashMap<>();
                    for (int j = 0; j < fields.length(); j++) {
                        fieldsMap.put(fields.getJSONObject(j).getString("name"), fields.getJSONObject(j).getString("value"));
                        try {
                            fields.getJSONObject(j).getString("verified_at");
                            fieldsMapVerified.put(fields.getJSONObject(j).getString("name"), !fields.getJSONObject(j).getString("verified_at").equals("null"));
                        } catch (Exception e) {
                            fieldsMapVerified.put(fields.getJSONObject(j).getString("name"), false);
                        }

                    }
                    account.setFields(fieldsMap);
                    account.setFieldsVerified(fieldsMapVerified);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }


            //Retrieves emjis
            List<Emojis> emojiList = new ArrayList<>();
            if (resobj.has("emojis")) {
                try {
                    JSONArray emojisTag = resobj.getJSONArray("emojis");
                    for (int j = 0; j < emojisTag.length(); j++) {
                        JSONObject emojisObj = emojisTag.getJSONObject(j);
                        Emojis emojis = parseEmojis(emojisObj);
                        emojiList.add(emojis);
                    }
                    account.setEmojis(emojiList);
                } catch (Exception e) {
                    account.setEmojis(new ArrayList<>());
                    e.printStackTrace();
                }
            } else {
                account.setEmojis(new ArrayList<>());
            }
            if (resobj.has("source")) {
                JSONObject source = resobj.getJSONObject("source");
                try {
                    if (source.has("privacy")) {
                        account.setPrivacy(source.getString("privacy"));
                    } else {
                        account.setPrivacy("public");
                    }
                    if (source.has("sensitive")) {
                        account.setSensitive(source.getBoolean("sensitive"));
                    } else {
                        account.setSensitive(false);
                    }

                } catch (Exception e) {
                    account.setPrivacy("public");
                    account.setSensitive(false);
                    e.printStackTrace();
                }
            }
        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        return account;
    }

    /**
     * Parse json response an unique account
     *
     * @param resobj JSONObject
     * @return Account
     */
    private static Account parseMisskeyAccountResponse(String instance, JSONObject resobj) {

        Account account = new Account();
        try {
            account.setId(resobj.getString("id"));
            account.setUsername(resobj.getString("username"));
            String host;
            String acct;
            if (resobj.isNull("host")) {
                acct = resobj.getString("username");
            } else {
                host = resobj.getString("host");
                acct = resobj.getString("username") + "@" + host;
            }
            account.setAcct(acct);
            account.setDisplay_name(resobj.getString("name"));
            account.setCreated_at(new Date());

            account.setUrl("https://" + instance + "/@" + account.getUsername());
            account.setAvatar(resobj.getString("avatarUrl"));
            account.setAvatar_static(resobj.getString("avatarUrl"));
            try {
                account.setBot(resobj.getBoolean("isBot"));
            } catch (Exception e) {
                account.setBot(false);
            }
            //Retrieves emjis
            List<Emojis> emojiList = new ArrayList<>();
            if (resobj.has("emojis")) {
                JSONArray emojisTag = resobj.getJSONArray("emojis");
                for (int j = 0; j < emojisTag.length(); j++) {
                    JSONObject emojisObj = emojisTag.getJSONObject(j);
                    Emojis emojis = parseEmojis(emojisObj);
                    emojiList.add(emojis);
                }
            }
            account.setEmojis(emojiList);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return account;
    }

    /**
     * Parse json response for list of relationship
     *
     * @param jsonArray JSONArray
     * @return List<Relationship>
     */
    private static List<Attachment> parseAttachmentResponse(JSONArray jsonArray) {

        List<Attachment> attachments = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Attachment attachment = parseAttachmentResponse(resobj);
                attachments.add(attachment);
                i++;
            }
        } catch (JSONException ignored) {
        }
        return attachments;
    }

    /**
     * Parse json response an unique attachment
     *
     * @param resobj JSONObject
     * @return Relationship
     */
    public static Attachment parseAttachmentResponse(JSONObject resobj) {

        Attachment attachment = new Attachment();
        try {
            attachment.setId(resobj.getString("id"));
            attachment.setType(resobj.getString("type"));
            attachment.setUrl(resobj.getString("url"));
            try {
                attachment.setDescription(resobj.getString("description"));
            } catch (JSONException ignore) {
            }
            try {
                attachment.setRemote_url(resobj.getString("remote_url"));
            } catch (JSONException ignore) {
            }
            if (attachment.getRemote_url() != null && attachment.getRemote_url().toLowerCase().compareTo("null") == 0) {
                attachment.setRemote_url(null);
            }
            try {
                attachment.setPreview_url(resobj.getString("preview_url"));
            } catch (JSONException ignore) {
            }
            if (attachment.getPreview_url() != null && attachment.getPreview_url().toLowerCase().compareTo("null") == 0) {
                attachment.setPreview_url(null);
            }
            try {
                attachment.setMeta(resobj.getString("meta"));
            } catch (JSONException ignore) {
            }
            if (attachment.getMeta() != null && attachment.getMeta().toLowerCase().compareTo("null") == 0) {
                attachment.setMeta(null);
            }
            try {
                attachment.setText_url(resobj.getString("text_url"));
            } catch (JSONException ignore) {
            }
            if (attachment.getText_url() != null && attachment.getText_url().toLowerCase().compareTo("null") == 0) {
                attachment.setText_url(null);
            }
            try {
                attachment.setMime(resobj.getString("mime"));
            } catch (JSONException ignore) {
            }
            if (attachment.getMime() != null && attachment.getMime().toLowerCase().compareTo("null") == 0) {
                attachment.setMime(null);
            }
            try {
                attachment.setFilter_class(resobj.getString("filter_class"));
            } catch (JSONException ignore) {
            }
            if (attachment.getFilter_class() != null && attachment.getFilter_class().toLowerCase().compareTo("null") == 0) {
                attachment.setFilter_class(null);
            }
            try {
                attachment.setFilter_name(resobj.getString("filter_name"));
            } catch (JSONException ignore) {
            }
            if (attachment.getFilter_name() != null && attachment.getFilter_name().toLowerCase().compareTo("null") == 0) {
                attachment.setFilter_name(null);
            }
            try {
                attachment.setLicense(resobj.getString("license"));
            } catch (JSONException ignore) {
            }
            if (attachment.getLicense() != null && attachment.getLicense().toLowerCase().compareTo("null") == 0) {
                attachment.setLicense(null);
            }
            try {
                attachment.setOrientation(resobj.getString("orientation"));
            } catch (JSONException ignore) {
            }
            if (attachment.getOrientation() != null && attachment.getOrientation().toLowerCase().compareTo("null") == 0) {
                attachment.setOrientation(null);
            }
        } catch (JSONException ignored) {
        }
        return attachment;
    }

    /**
     * Parse json response an unique notification
     *
     * @param resobj JSONObject
     * @return Account
     */
    public static Notification parseNotificationResponse(Context context, JSONObject resobj) {


        Notification notification = new Notification();
        try {
            notification.setId(resobj.getString("id"));
            notification.setType(resobj.getString("type"));
            notification.setCreated_at(Helper.mstStringToDate(resobj.getString("created_at")));
            notification.setAccount(parseAccountResponse(resobj.getJSONObject("account")));
            if (resobj.has("status")) {
                try {
                    notification.setStatus(parseStatuses(context, resobj.getJSONObject("status"), false));
                } catch (Exception ignored) {
                }
            }
            notification.setCreated_at(Helper.mstStringToDate(resobj.getString("created_at")));
        } catch (JSONException ignored) {
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return notification;
    }

    /**
     * Parse xml response for Nitter
     *
     * @param xml String
     * @return List<Status>
     */

    private List<Status> parseNitter(String xml) {
        final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        String nitterHost = sharedpreferences.getString(Helper.SET_NITTER_HOST, Helper.DEFAULT_NITTER_HOST).toLowerCase();
        List<Status> statuses = new ArrayList<>();
        try {
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            factory.setNamespaceAware(true);
            XmlPullParser xpp = factory.newPullParser();

            xpp.setInput(new StringReader(xml));
            int eventType = xpp.getEventType();
            Account account = null;
            Status status = null;
            HashMap<String, String> mappedProfile = new HashMap<>();
            while (eventType != XmlPullParser.END_DOCUMENT) {
                if (eventType == XmlPullParser.START_TAG) {
                    if (xpp.getName().compareTo("item") == 0) {
                        status = new Status();
                        status.setReplies_count(0);
                        status.setFavourites_count(0);
                        status.setReblogs_count(0);
                        status.setFavourited(false);
                        status.setReblogged(false);
                        status.setEmojiFound(true);
                        status.setPollEmojiFound(true);
                        status.setEmojiTranslateFound(true);
                        status.setMedia_attachments(new ArrayList<>());
                        account = new Account();
                    } else if (xpp.getName().compareTo("creator") == 0) {
                        eventType = xpp.next();
                        if (eventType == XmlPullParser.TEXT) {
                            if (account != null) {
                                account.setAcct(xpp.getText().replace("@", "") + "@" + nitterHost);
                                account.setDisplay_name(xpp.getText().replace("@", ""));
                                account.setUsername(xpp.getText().replace("@", ""));
                                account.setId("https://" + nitterHost + "/" + xpp.getText());
                                account.setUuid("https://" + nitterHost + "/" + xpp.getText());
                                account.setUrl("https://" + nitterHost + "/" + xpp.getText());
                                if (!mappedProfile.containsKey(xpp.getText())) {
                                    HttpsConnection httpsConnection = new HttpsConnection(context, nitterHost);
                                    try {
                                        String response = httpsConnection.get("https://" + nitterHost + "/" + xpp.getText() + "/rss", 10, null, null);
                                        XmlPullParserFactory factory2 = XmlPullParserFactory.newInstance();
                                        factory2.setNamespaceAware(true);
                                        XmlPullParser xpp2 = factory2.newPullParser();

                                        xpp2.setInput(new StringReader(response));
                                        int eventType2 = xpp2.getEventType();
                                        while (eventType2 != XmlPullParser.END_DOCUMENT) {
                                            if (eventType2 == XmlPullParser.START_TAG) {
                                                if (xpp2.getName().compareTo("url") == 0) {
                                                    eventType2 = xpp2.next();
                                                    if (eventType2 == XmlPullParser.TEXT) {
                                                        mappedProfile.put(xpp.getText(), xpp2.getText());
                                                    }
                                                    break;
                                                }
                                            }
                                            eventType2 = xpp2.next();
                                        }
                                    } catch (NoSuchAlgorithmException | KeyManagementException | HttpsConnection.HttpsConnectionException e) {
                                        e.printStackTrace();
                                    }
                                }
                                account.setAvatar(mappedProfile.get(xpp.getText()));
                                account.setAvatar_static(mappedProfile.get(xpp.getText()));
                            }
                        }
                    } else if (xpp.getName().compareTo("pubDate") == 0) {
                        eventType = xpp.next();
                        if (eventType == XmlPullParser.TEXT && status != null) {
                            if (xpp.getText() != null) {
                                try {
                                    DateFormat formatter = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.ENGLISH);
                                    Date date = formatter.parse(xpp.getText());
                                    status.setCreated_at(date);
                                } catch (ParseException e) {
                                    status.setCreated_at(new Date());
                                }
                            }
                        }
                    } else if (xpp.getName().compareTo("description") == 0) {
                        eventType = xpp.next();
                        if (eventType == XmlPullParser.TEXT && status != null) {
                            if (xpp.getText() != null) {
                                String description = xpp.getText();
                                Pattern imgPattern = Pattern.compile("<img [^>]*src=\"([^\"]+)\"[^>]*>");
                                Matcher matcher = imgPattern.matcher(description);
                                ArrayList<Attachment> attachments = new ArrayList<>();
                                while (matcher.find()) {
                                    description = description.replaceAll(Pattern.quote(matcher.group()), "");
                                    Attachment attachment = new Attachment();
                                    attachment.setType("image");
                                    attachment.setDescription("");
                                    attachment.setUrl(matcher.group(1));
                                    attachment.setPreview_url(matcher.group(1));
                                    attachment.setId(matcher.group(1));
                                    attachments.add(attachment);
                                }
                                status.setMedia_attachments(attachments);
                                status.setContent(context, description);
                            }
                        }
                    } else if (xpp.getName().compareTo("guid") == 0) {
                        eventType = xpp.next();
                        if (eventType == XmlPullParser.TEXT && status != null) {
                            if (xpp.getText() != null) {
                                status.setUri(xpp.getText());
                                Pattern idPattern = Pattern.compile("([0-9])+");
                                Matcher matcher = idPattern.matcher(xpp.getText());
                                while (matcher.find()) {
                                    status.setId(matcher.group(0));
                                }
                            }
                        }
                    } else if (xpp.getName().compareTo("link") == 0) {
                        eventType = xpp.next();
                        if (eventType == XmlPullParser.TEXT && status != null) {
                            if (xpp.getText() != null) {
                                status.setUrl(xpp.getText());
                            }
                        }
                    }
                } else if (eventType == XmlPullParser.END_TAG) {
                    if (xpp.getName().compareTo("item") == 0) {
                        if (status != null) {
                            status.setAccount(account);
                            Status.fillSpan(new WeakReference<>(context), status);
                            statuses.add(status);
                        }
                        account = null;
                        status = null;
                    }
                }
                eventType = xpp.next();
            }
        } catch (XmlPullParserException | IOException e) {
            e.printStackTrace();
        }
        return statuses;
    }

    private List<IdentityProof> parseIdentityProof(JSONArray jsonArray) {
        List<IdentityProof> identityProofs = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                IdentityProof identityProof = parseIdentityProof(resobj);
                i++;
                identityProofs.add(identityProof);
            }

        } catch (JSONException e) {
            e.printStackTrace();
        }
        return identityProofs;
    }

    private IdentityProof parseIdentityProof(JSONObject jsonObject) {
        IdentityProof identityProof = new IdentityProof();
        try {
            identityProof.setProfile_url(jsonObject.getString("profile_url"));
            identityProof.setProof_url(jsonObject.getString("proof_url"));
            identityProof.setProvider(jsonObject.getString("provider"));
            identityProof.setProvider_username(jsonObject.getString("provider_username"));
            identityProof.setUpdated_at(Helper.mstStringToDate(jsonObject.getString("updated_at")));

        } catch (JSONException | ParseException e) {
            e.printStackTrace();
        }
        return identityProof;
    }

    /**
     * Execute admin get actions
     *
     * @param action type of the action
     * @param id     String can for an account or a status
     * @return APIResponse
     */
    public APIResponse adminGet(adminAction action, String id, AdminAction adminAction) {
        apiResponse = new APIResponse();
        HashMap<String, String> params = null;
        String endpoint = null;
        String url_action = null;
        switch (action) {
            case GET_ACCOUNTS:
                params = new HashMap<>();
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    if (adminAction.isLocal())
                        params.put("local", String.valueOf(adminAction.isLocal()));
                    if (adminAction.isRemote())
                        params.put("remote", String.valueOf(adminAction.isRemote()));
                    if (adminAction.isActive())
                        params.put("active", String.valueOf(adminAction.isActive()));
                    if (adminAction.isPending())
                        params.put("pending", String.valueOf(adminAction.isPending()));
                    if (adminAction.isDisabled())
                        params.put("disabled", String.valueOf(adminAction.isDisabled()));
                    if (adminAction.isSilenced())
                        params.put("silenced", String.valueOf(adminAction.isSilenced()));
                    if (adminAction.isSuspended())
                        params.put("suspended", String.valueOf(adminAction.isSuspended()));
                    endpoint = "/admin/accounts";
                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    if (adminAction.isLocal())
                        params.put("filters", "local");
                    if (adminAction.isRemote())
                        params.put("filters", "external");
                    if (adminAction.isActive())
                        params.put("filters", "active");
                    if (adminAction.isDisabled())
                        params.put("filters", "deactivated");
                    endpoint = "/admin/users";
                }
                break;
            case GET_ONE_ACCOUNT:
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    endpoint = String.format("/admin/accounts/%s", id);
                } else {
                    try {
                        id = URLEncoder.encode(id, "UTF-8");
                    } catch (UnsupportedEncodingException ignored) {
                    }
                    params = new HashMap<>();
                    params.put("query", id);
                    endpoint = "/admin/users";

                }
                break;
            case GET_REPORTS:
                endpoint = "/admin/reports";
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    if (!adminAction.isUnresolved()) {
                        params = new HashMap<>();
                        params.put("resolved", "present");
                    }
                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    if (adminAction.isUnresolved()) {
                        params = new HashMap<>();
                        params.put("state", "open");
                    } else {
                        params = new HashMap<>();
                        params.put("state", "resolved");
                    }
                }
                break;
            case GET_ONE_REPORT:
                endpoint = String.format("/admin/reports/%s", id);
                break;
        }
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
            url_action = getAbsoluteUrl(endpoint);

        } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
            url_action = Helper.instanceWithProtocol(this.context, this.instance) + "/api/pleroma" + endpoint;
        }
        if (url_action == null) {
            apiResponse = new APIResponse();
            APIError = new Error();
            APIError.setError(context.getString(R.string.toast_error));
            apiResponse.setError(APIError);
            return apiResponse;
        }
        try {
            String response = new HttpsConnection(context, this.instance).get(url_action, 10, params, prefKeyOauthTokenT);
            if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                if (new JSONObject(response).has("users")) {
                    response = new JSONArray(new JSONObject(response).getJSONArray("users").toString()).toString();
                } else if (new JSONObject(response).has("reports")) {
                    response = new JSONArray(new JSONObject(response).getJSONArray("reports").toString()).toString();
                }
            }
            switch (action) {
                case GET_ACCOUNTS:
                    List<AccountAdmin> accountAdmins = parseAccountAdminResponse(new JSONArray(response));
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
                case GET_ONE_ACCOUNT:

                    if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                        accountAdmins = parseAccountAdminResponse(new JSONArray(response));
                        if (accountAdmins.size() > 0) {
                            Account accountpleroma = getAccount(accountAdmins.get(0).getId());
                            if (accountpleroma != null) {
                                accountAdmins.get(0).setAccount(accountpleroma);
                            }
                        }
                    } else {
                        AccountAdmin accountAdmin = parseAccountAdminResponse(new JSONObject(response));
                        accountAdmins = new ArrayList<>();
                        accountAdmins.add(accountAdmin);
                    }
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
                case GET_REPORTS:
                    List<Report> reports = parseReportAdminResponse(new JSONArray(response));
                    apiResponse.setReports(reports);
                    break;
                case GET_ONE_REPORT:
                    reports = new ArrayList<>();
                    Report report = parseReportAdminResponse(context, new JSONObject(response));
                    reports.add(report);
                    apiResponse.setReports(reports);
                    break;
            }
        } catch (IOException | NoSuchAlgorithmException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Execute admin post actions
     *
     * @param action type of the action
     * @param id     String can for an account or a status
     * @return APIResponse
     */
    public APIResponse adminDo(adminAction action, String id, AdminAction adminAction) {
        apiResponse = new APIResponse();
        String http_action = "POST";
        String endpoint = null;
        String url_action = null;
        HashMap<String, String> params = null;
        switch (action) {
            case ENABLE:
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    endpoint = String.format("/admin/accounts/%s/enable", id);
                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    http_action = "PATCH";
                    endpoint = String.format("/admin/users/%s/toggle_activation", id);
                }
                break;
            case APPROVE:
                endpoint = String.format("/admin/accounts/%s/approve", id);
                break;
            case REJECT:
                endpoint = String.format("/admin/accounts/%s/reject", id);
                break;
            case UNSILENCE:
                endpoint = String.format("/admin/accounts/%s/unsilence", id);
                break;
            case UNSUSPEND:
                endpoint = String.format("/admin/accounts/%s/unsuspend", id);
                break;
            case ASSIGN_TO_SELF:
                endpoint = String.format("/admin/reports/%s/assign_to_self", id);
                break;
            case UNASSIGN:
                endpoint = String.format("/admin/reports/%s/unassign", id);
                break;
            case REOPEN:
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    endpoint = String.format("/admin/reports/%s/reopen", id);
                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    endpoint = String.format("/admin/reports/%s", id);
                    params = new HashMap<>();
                    params.put("state", "open");
                    http_action = "PUT";
                }
                break;
            case RESOLVE:
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    endpoint = String.format("/admin/reports/%s/resolve", id);
                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    endpoint = String.format("/admin/reports/%s", id);
                    params = new HashMap<>();
                    params.put("state", "resolved");
                    http_action = "PUT";
                }
                break;
            case NONE:
                params = new HashMap<>();
                params.put("type", "none");
                endpoint = String.format("/admin/accounts/%s/action", id);
                params.put("send_email_notification", String.valueOf(adminAction.isSend_email_notification()));
                if (adminAction.getText() != null) {
                    params.put("text", adminAction.getText());
                }
                break;
            case DISABLE:

                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    params = new HashMap<>();
                    params.put("type", "disable");
                    endpoint = String.format("/admin/accounts/%s/action", id);
                    params.put("send_email_notification", String.valueOf(adminAction.isSend_email_notification()));
                    if (adminAction.getText() != null) {
                        params.put("text", adminAction.getText());
                    }

                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    http_action = "PATCH";
                    endpoint = String.format("/admin/users/%s/toggle_activation", id);
                }
                break;
            case SILENCE:

                params = new HashMap<>();
                params.put("type", "silence");
                endpoint = String.format("/admin/accounts/%s/action", id);
                params.put("send_email_notification", String.valueOf(adminAction.isSend_email_notification()));
                if (adminAction.getText() != null) {
                    params.put("text", adminAction.getText());
                }
                break;
            case SUSPEND:
                if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
                    params = new HashMap<>();
                    params.put("type", "suspend");
                    endpoint = String.format("/admin/accounts/%s/action", id);
                    params.put("send_email_notification", String.valueOf(adminAction.isSend_email_notification()));
                    if (adminAction.getText() != null) {
                        params.put("text", adminAction.getText());
                    }
                } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
                    http_action = "DELETE";
                    endpoint = "/admin/users";
                    params = new HashMap<>();
                    params.put("nickname", id);
                }
                break;
        }
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON) {
            url_action = getAbsoluteUrl(endpoint);

        } else if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
            url_action = Helper.instanceWithProtocol(this.context, this.instance) + "/api/pleroma" + endpoint;
        }
        try {
            String response = null;
            switch (http_action) {
                case "POST":
                    assert url_action != null;
                    response = new HttpsConnection(context, this.instance).post(url_action, 10, params, prefKeyOauthTokenT);
                    break;
                case "PATCH":
                    assert url_action != null;
                    response = new HttpsConnection(context, this.instance).patch(url_action, 10, null, null, null, null, null, prefKeyOauthTokenT);
                    break;
                case "PUT":
                    assert url_action != null;
                    response = new HttpsConnection(context, this.instance).put(url_action, 10, params, prefKeyOauthTokenT);
                    break;
                case "DELETE":
                    assert url_action != null;
                    new HttpsConnection(context, this.instance).delete(url_action, 10, params, prefKeyOauthTokenT);
                    break;
            }
            switch (action) {
                case ENABLE:
                case APPROVE:
                case REJECT:
                case UNSILENCE:
                    // case UNDISABLE:
                case UNSUSPEND:
                    List<AccountAdmin> accountAdmins = null;
                    try {
                        AccountAdmin accountAdmin = parseAccountAdminResponse(new JSONObject(response));
                        accountAdmin.setAction(action);
                        accountAdmins = new ArrayList<>();
                        accountAdmins.add(accountAdmin);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
                case ASSIGN_TO_SELF:
                case UNASSIGN:
                case REOPEN:
                case RESOLVE:
                    List<Report> reports = null;
                    Report report;
                    try {
                        reports = new ArrayList<>();
                        report = parseReportAdminResponse(context, new JSONObject(response));
                        reports.add(report);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    apiResponse.setReports(reports);

                    break;
                case NONE:
                    accountAdmins = new ArrayList<>();
                    AccountAdmin accountAdmin = new AccountAdmin();
                    accountAdmin.setAction(action);
                    accountAdmins.add(accountAdmin);
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
                case DISABLE:
                    accountAdmins = new ArrayList<>();
                    accountAdmin = new AccountAdmin();
                    accountAdmin.setDisabled(true);
                    accountAdmin.setAction(action);
                    accountAdmins.add(accountAdmin);
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
                case SILENCE:
                    accountAdmins = new ArrayList<>();
                    accountAdmin = new AccountAdmin();
                    accountAdmin.setSilenced(true);
                    accountAdmin.setAction(action);
                    accountAdmins.add(accountAdmin);
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
                case SUSPEND:
                    accountAdmins = new ArrayList<>();
                    accountAdmin = new AccountAdmin();
                    accountAdmin.setSuspended(true);
                    accountAdmin.setAction(action);
                    accountAdmins.add(accountAdmin);
                    apiResponse.setAccountAdmins(accountAdmins);
                    break;
            }
        } catch (IOException | NoSuchAlgorithmException | KeyManagementException e) {
            e.printStackTrace();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        }
        return apiResponse;
    }

    public InstanceNodeInfo displayNodeInfo(String domain) {

        if (domain == null) {
            return null;
        }
        String response;
        InstanceNodeInfo instanceNodeInfo = new InstanceNodeInfo();
        if (domain.startsWith("http://")) {
            domain = domain.replace("http://", "");
        }
        if (domain.startsWith("https://")) {
            domain = domain.replace("https://", "");
        }
        try {
            response = new HttpsConnection(context, domain).get("https://" + domain + "/.well-known/nodeinfo", 30, null, null);
            JSONArray jsonArray = new JSONObject(response).getJSONArray("links");
            ArrayList<NodeInfo> nodeInfos = new ArrayList<>();
            try {
                int i = 0;
                while (i < jsonArray.length()) {

                    JSONObject resobj = jsonArray.getJSONObject(i);
                    NodeInfo nodeInfo = new NodeInfo();
                    nodeInfo.setHref(resobj.getString("href"));
                    nodeInfo.setRel(resobj.getString("rel"));
                    i++;
                    nodeInfos.add(nodeInfo);
                }
                if (nodeInfos.size() > 0) {
                    NodeInfo nodeInfo = nodeInfos.get(nodeInfos.size() - 1);
                    response = new HttpsConnection(context, this.instance).get(nodeInfo.getHref(), 30, null, null);
                    JSONObject resobj = new JSONObject(response);
                    JSONObject jsonObject = resobj.getJSONObject("software");
                    String name = jsonObject.getString("name").toUpperCase();
                    if (name.compareTo("CORGIDON") == 0) {
                        name = "MASTODON";
                    }
                    instanceNodeInfo.setName(name);
                    instanceNodeInfo.setVersion(jsonObject.getString("version"));
                    instanceNodeInfo.setOpenRegistrations(resobj.getBoolean("openRegistrations"));
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        } catch (IOException | JSONException | NoSuchAlgorithmException | KeyManagementException e) {
            e.printStackTrace();
            try {
                response = new HttpsConnection(context, this.instance).get("https://" + domain + "/api/v1/instance", 30, null, null);
                JSONObject jsonObject = new JSONObject(response);
                instanceNodeInfo.setName("MASTODON");
                instanceNodeInfo.setVersion(jsonObject.getString("version"));
                instanceNodeInfo.setOpenRegistrations(true);
            } catch (IOException e1) {
                instanceNodeInfo.setConnectionError(true);
                e1.printStackTrace();
            } catch (NoSuchAlgorithmException | JSONException | KeyManagementException e1) {
                e1.printStackTrace();
            } catch (HttpsConnection.HttpsConnectionException e1) {
                if (e1.getStatusCode() == 404 || e1.getStatusCode() == 501) {
                    instanceNodeInfo.setName("GNU");
                    instanceNodeInfo.setVersion("unknown");
                    instanceNodeInfo.setOpenRegistrations(true);
                    e1.printStackTrace();
                } else {
                    instanceNodeInfo.setName("MASTODON");
                    instanceNodeInfo.setVersion("3.0");
                    instanceNodeInfo.setOpenRegistrations(false);
                }
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            try {
                response = new HttpsConnection(context, this.instance).get("https://" + domain + "/api/v1/instance", 30, null, null);
                JSONObject jsonObject = new JSONObject(response);
                instanceNodeInfo.setName("MASTODON");
                instanceNodeInfo.setVersion(jsonObject.getString("version"));
                instanceNodeInfo.setOpenRegistrations(true);
            } catch (IOException e1) {
                instanceNodeInfo.setConnectionError(true);
                e1.printStackTrace();
            } catch (NoSuchAlgorithmException | JSONException | KeyManagementException e1) {
                e1.printStackTrace();
            } catch (HttpsConnection.HttpsConnectionException e1) {
                if (e1.getStatusCode() == 404 || e1.getStatusCode() == 501) {
                    instanceNodeInfo.setName("GNU");
                    instanceNodeInfo.setVersion("unknown");
                    instanceNodeInfo.setOpenRegistrations(true);
                    e1.printStackTrace();
                } else {
                    instanceNodeInfo.setName("MASTODON");
                    instanceNodeInfo.setVersion("3.0");
                    instanceNodeInfo.setOpenRegistrations(false);
                }
            }
            e.printStackTrace();
        }
        return instanceNodeInfo;
    }

    public InstanceNodeInfo instanceInfo(String domain) {

        String response;
        InstanceNodeInfo instanceNodeInfo = null;
        try {
            response = new HttpsConnection(context, domain).get("https://" + domain + "/.well-known/nodeinfo", 30, null, null);
            JSONArray jsonArray = new JSONObject(response).getJSONArray("links");
            ArrayList<NodeInfo> nodeInfos = new ArrayList<>();
            try {
                instanceNodeInfo = new InstanceNodeInfo();
                int i = 0;
                while (i < jsonArray.length()) {

                    JSONObject resobj = jsonArray.getJSONObject(i);
                    NodeInfo nodeInfo = new NodeInfo();
                    nodeInfo.setHref(resobj.getString("href"));
                    nodeInfo.setRel(resobj.getString("rel"));
                    i++;
                    nodeInfos.add(nodeInfo);
                }
                if (nodeInfos.size() > 0) {
                    NodeInfo nodeInfo = nodeInfos.get(nodeInfos.size() - 1);
                    response = new HttpsConnection(context, this.instance).get(nodeInfo.getHref(), 30, null, null);
                    JSONObject resobj = new JSONObject(response);
                    JSONObject jsonObject = resobj.getJSONObject("software");
                    String name;
                    name = jsonObject.getString("name").toUpperCase();
                    instanceNodeInfo.setName(name);
                    instanceNodeInfo.setVersion(jsonObject.getString("version"));
                    instanceNodeInfo.setOpenRegistrations(resobj.getBoolean("openRegistrations"));
                    if (name.trim().toUpperCase().compareTo("MASTODON") == 0 || name.trim().toUpperCase().compareTo("PLEROMA") == 0 || name.trim().toUpperCase().compareTo("PIXELFED") == 0) {
                        APIResponse apiResponse = getInstance(domain);
                        Instance instanceNode = apiResponse.getInstance();
                        instanceNodeInfo.setNodeDescription(instanceNode.getDescription());
                        instanceNodeInfo.setNumberOfUsers(instanceNode.getUserCount());
                        instanceNodeInfo.setNumberOfPosts(instanceNode.getStatusCount());
                        instanceNodeInfo.setNumberOfInstance(instanceNode.getDomainCount());
                        instanceNodeInfo.setStaffAccount(instanceNode.getContactAccount());
                        instanceNodeInfo.setNodeName(instanceNode.getTitle());
                        instanceNodeInfo.setThumbnail(instanceNode.getThumbnail());
                        instanceNodeInfo.setVersion(instanceNode.getVersion());
                    }
                    if (resobj.has("metadata")) {
                        JSONObject metadata = resobj.getJSONObject("metadata");
                        if (metadata.has("staffAccounts")) {
                            instanceNodeInfo.setStaffAccountStr(metadata.getString("staffAccounts"));
                        }
                        if (metadata.has("nodeName")) {
                            instanceNodeInfo.setNodeName(metadata.getString("nodeName"));
                        }
                    }
                    if (resobj.has("usage")) {
                        JSONObject usage = resobj.getJSONObject("usage");
                        if (usage.has("users") && usage.getJSONObject("users").has("total")) {
                            instanceNodeInfo.setNumberOfUsers(usage.getJSONObject("users").getInt("total"));
                        }
                        if (usage.has("localPosts")) {
                            instanceNodeInfo.setNumberOfPosts(usage.getInt("localPosts"));
                        }
                    }
                    if (instanceNodeInfo.getStaffAccountStr() != null && instanceNodeInfo.getStaffAccount() == null) {
                        APIResponse search = searchAccounts(instanceNodeInfo.getStaffAccountStr(), 1);
                        if (search != null && search.getAccounts() != null && search.getAccounts().size() > 0) {
                            instanceNodeInfo.setStaffAccount(search.getAccounts().get(0));
                        }
                    }
                }
            } catch (JSONException e) {
                setDefaultError(e);
            }
        } catch (IOException | JSONException | NoSuchAlgorithmException | KeyManagementException e) {
            e.printStackTrace();
        } catch (HttpsConnection.HttpsConnectionException e) {
            APIResponse apiResponse = getInstance(domain);
            instanceNodeInfo = new InstanceNodeInfo();
            instanceNodeInfo.setName("MASTODON");
            Instance instanceNode = apiResponse.getInstance();
            instanceNodeInfo.setNodeDescription(instanceNode.getDescription());
            instanceNodeInfo.setNumberOfUsers(instanceNode.getUserCount());
            instanceNodeInfo.setNumberOfPosts(instanceNode.getStatusCount());
            instanceNodeInfo.setNumberOfInstance(instanceNode.getDomainCount());
            instanceNodeInfo.setStaffAccount(instanceNode.getContactAccount());
            instanceNodeInfo.setNodeName(instanceNode.getTitle());
            instanceNodeInfo.setThumbnail(instanceNode.getThumbnail());
            instanceNodeInfo.setVersion(instanceNode.getVersion());
        }
        return instanceNodeInfo;
    }

    /***
     * Get info on the current Instance *synchronously*
     * @return APIResponse
     */
    public APIResponse getInstance(String instance) {
        try {
            String response = new HttpsConnection(context, this.instance).get("https://" + instance + "/api/v1/instance", 30, null, prefKeyOauthTokenT);
            Instance instanceEntity = parseInstance(new JSONObject(response));
            apiResponse.setInstance(instanceEntity);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /***
     * Get info on the current Instance *synchronously*
     * @return APIResponse
     */
    public APIResponse getInstance() {
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/instance"), 30, null, prefKeyOauthTokenT);
            Instance instanceEntity = parseInstance(new JSONObject(response));
            apiResponse.setInstance(instanceEntity);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /***
     * Get instance for registering an account *synchronously*
     * @return APIResponse
     */
    public APIResponse getInstanceReg(String category) {
        apiResponse = new APIResponse();
        try {
            String response = new HttpsConnection(context, null).get(String.format("https://api.joinmastodon.org/servers?category=%s", category));
            List<InstanceReg> instanceRegs = parseInstanceReg(new JSONArray(response));
            apiResponse.setInstanceRegs(instanceRegs);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /***
     * Update credential of the authenticated user *synchronously*
     * @return APIResponse
     */
    public APIResponse updateCredential(String display_name, String note, ByteArrayInputStream avatar, String avatarName, ByteArrayInputStream header, String headerName, accountPrivacy privacy, HashMap<String, String> customFields, boolean sensitive) {

        HashMap<String, String> requestParams = new HashMap<>();
        if (display_name != null)
            try {
                requestParams.put("display_name", URLEncoder.encode(display_name, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                requestParams.put("display_name", display_name);
            }
        if (note != null && MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON)
            try {
                requestParams.put("note", URLEncoder.encode(note, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                requestParams.put("note", note);
            }
        if (privacy != null)
            requestParams.put("locked", privacy == accountPrivacy.LOCKED ? "true" : "false");
        int i = 0;
        if (customFields != null && customFields.size() > 0) {
            Iterator<Map.Entry<String, String>> it = customFields.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<String, String> pair = it.next();
                requestParams.put("fields_attributes[" + i + "][name]", pair.getKey());
                requestParams.put("fields_attributes[" + i + "][value]", pair.getValue());
                it.remove();
                i++;
            }
        }
        requestParams.put("source[sensitive]", String.valueOf(sensitive));
        try {
            new HttpsConnection(context, this.instance).patch(getAbsoluteUrl("/accounts/update_credentials"), 10, requestParams, avatar, avatarName, header, headerName, prefKeyOauthTokenT);
        } catch (HttpsConnection.HttpsConnectionException e) {
            e.printStackTrace();
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /***
     * Verifiy credential of the authenticated user *synchronously*
     * @return Account
     */
    public Account verifyCredentials() {
        account = new Account();
        InstanceNodeInfo nodeinfo = displayNodeInfo(instance);
        String social = null;
        if (nodeinfo != null) {
            social = nodeinfo.getName();
        }
        try {
            if (context == null) {
                setError(500, new Throwable("An error occured!"));
                return null;
            }
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/accounts/verify_credentials"), 10, null, prefKeyOauthTokenT);
            account = parseAccountResponse(new JSONObject(response));
            if (social != null) {
                account.setSocial(social.toUpperCase());
            }
            if (account != null && account.getSocial() != null && account.getSocial().equals("PLEROMA")) {
                isPleromaAdmin(account.getAcct());
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            e.printStackTrace();
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return account;
    }


    /***
     * Verifiy credential of the authenticated user *synchronously*
     */
    public void refreshToken(Account account) {
        HashMap<String, String> params = new HashMap<>();
        params.put("grant_type", "refresh_token");
        params.put("client_id", account.getClient_id());
        params.put("client_secret", account.getClient_secret());
        params.put("refresh_token", account.getRefresh_token());
        SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
        try {
            String response;
            if (account.getSocial().compareTo("PEERTUBE") == 0) {

                response = new HttpsConnection(context, instance).post(getAbsoluteUrl("/users/token"), 60, params, null);
            } else {
                response = new HttpsConnection(context, instance).post("https://" + instance + "/oauth/token", 60, params, null);
            }
            JSONObject resobj = new JSONObject(response);
            String newToken = resobj.getString("access_token");
            String newRefreshToken = resobj.getString("refresh_token");
            final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sharedpreferences.edit();
            editor.putString(Helper.PREF_KEY_OAUTH_TOKEN, newToken);
            editor.apply();
            if (account.getSocial().compareTo("PEERTUBE") == 0) {
                response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/users/me"), 60, null, newToken);
                JSONObject accountObject = new JSONObject(response).getJSONObject("account");
                account = parseAccountResponsePeertube(instance, accountObject);
            } else {
                response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/accounts/verify_credentials"), 10, null, newToken);
                account = parseAccountResponse(new JSONObject(response));
            }
            account.setRefresh_token(newRefreshToken);
            account.setToken(newToken);
            if (account.getHeader() == null) {
                account.setHeader("");
                account.setHeader_static("");
            }
            account.setInstance(instance);
            new AccountDAO(context, db).updateAccount(account);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        }
    }

    public APIResponse createAccount(AccountCreation accountCreation) {
        apiResponse = new APIResponse();

        try {
            HashMap<String, String> params = new HashMap<>();
            params.put(Helper.CLIENT_NAME, Helper.CLIENT_NAME_VALUE);
            params.put(Helper.REDIRECT_URIS, Helper.REDIRECT_CONTENT);
            params.put(Helper.SCOPES, Helper.OAUTH_SCOPES);
            params.put(Helper.WEBSITE, Helper.WEBSITE_VALUE);
            String response = new HttpsConnection(context, this.instance).post(getAbsoluteUrl("/apps"), 30, params, null);
            JSONObject resobj = new JSONObject(response);
            String client_id = resobj.getString("client_id");
            String client_secret = resobj.getString("client_secret");

            params = new HashMap<>();
            params.put("grant_type", "client_credentials");
            params.put("client_id", client_id);
            params.put("client_secret", client_secret);
            params.put("scope", "read write");
            response = new HttpsConnection(context, this.instance).post("https://" + this.instance + "/oauth/token", 30, params, null);
            JSONObject res = new JSONObject(response);
            String app_token = res.getString("access_token");
            params = new HashMap<>();
            params.put("username", accountCreation.getUsername());
            params.put("email", accountCreation.getEmail());
            params.put("password", accountCreation.getPassword());
            params.put("agreement", "true");
            params.put("locale", Locale.getDefault().getLanguage());
            new HttpsConnection(context, this.instance).post(getAbsoluteUrl("/accounts"), 30, params, app_token);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Returns an account
     *
     * @param accountId String account fetched
     * @return Account entity
     */
    public Account getAccount(String accountId) {

        account = new Account();
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl(String.format("/accounts/%s", accountId)), 10, null, prefKeyOauthTokenT);
            account = parseAccountResponse(new JSONObject(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return account;
    }

    /**
     * Returns a relationship between the authenticated account and an account
     *
     * @param accountId String account fetched
     * @return Relationship entity
     */
    public Relationship getRelationship(String accountId) {

        List<Relationship> relationships;
        Relationship relationship = null;
        HashMap<String, String> params = new HashMap<>();
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED)
            params.put("id[]", accountId);
        else
            params.put("id", accountId);
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/accounts/relationships"), 10, params, prefKeyOauthTokenT);
            relationships = parseRelationshipResponse(new JSONArray(response));
            if (relationships.size() > 0)
                relationship = relationships.get(0);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return relationship;
    }

    /**
     * Returns a relationship between the authenticated account and an account
     *
     * @param accounts ArrayList<Account> accounts fetched
     * @return Relationship entity
     */
    public APIResponse getRelationship(List<Account> accounts) {
        HashMap<String, String> params = new HashMap<>();
        if (accounts != null && accounts.size() > 0) {
            StringBuilder parameters = new StringBuilder();
            for (Account account : accounts)
                parameters.append("id[]=").append(account.getId()).append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(5));
            params.put("id[]", parameters.toString());
            List<Relationship> relationships = new ArrayList<>();
            try {
                HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
                String response = httpsConnection.get(getAbsoluteUrl("/accounts/relationships"), 10, params, prefKeyOauthTokenT);
                relationships = parseRelationshipResponse(new JSONArray(response));
                apiResponse.setSince_id(httpsConnection.getSince_id());
                apiResponse.setMax_id(httpsConnection.getMax_id());
            } catch (HttpsConnection.HttpsConnectionException e) {
                setError(e.getStatusCode(), e);
            } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
                e.printStackTrace();
            }
            apiResponse.setRelationships(relationships);
        }

        return apiResponse;
    }

    /**
     * Retrieves status for the account *synchronously*
     *
     * @param accountId String Id of the account
     * @return APIResponse
     */
    public APIResponse getStatus(String accountId) {
        return getStatus(accountId, false, false, false, null, null, tootPerPage);
    }

    /**
     * Retrieves status for the account *synchronously*
     *
     * @param accountId String Id of the account
     * @param max_id    String id max
     * @return APIResponse
     */
    public APIResponse getStatus(String accountId, String max_id) {
        return getStatus(accountId, false, false, false, max_id, null, tootPerPage);
    }

    /**
     * Retrieves status with media for the account *synchronously*
     *
     * @param accountId String Id of the account
     * @param max_id    String id max
     * @return APIResponse
     */
    public APIResponse getStatusWithMedia(String accountId, String max_id) {
        return getStatus(accountId, true, false, false, max_id, null, tootPerPage);
    }

    /**
     * Retrieves pinned status(es) *synchronously*
     *
     * @param accountId String Id of the account
     * @param max_id    String id max
     * @return APIResponse
     */
    public APIResponse getPinnedStatuses(String accountId, String max_id) {
        return getStatus(accountId, false, true, false, max_id, null, tootPerPage);
    }

    /**
     * Retrieves replies status(es) *synchronously*
     *
     * @param accountId String Id of the account
     * @param max_id    String id max
     * @return APIResponse
     */
    public APIResponse getAccountTLStatuses(String accountId, String max_id, boolean exclude_replies) {
        return getStatus(accountId, false, false, exclude_replies, max_id, null, tootPerPage);
    }

    /**
     * Retrieves status for the account *synchronously*
     *
     * @param accountId       String Id of the account
     * @param onlyMedia       boolean only with media
     * @param exclude_replies boolean excludes replies
     * @param max_id          String id max
     * @param since_id        String since the id
     * @param limit           int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getStatus(String accountId, boolean onlyMedia, boolean pinned,
                                  boolean exclude_replies, String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        if (pinned)
            params.put("pinned", Boolean.toString(true));
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            params.put("only_media", Boolean.toString(true));
            if (max_id == null) {
                params.put("min_id", "1");
            }
        } else {
            if (onlyMedia)
                params.put("only_media", Boolean.toString(true));
        }
        params.put("exclude_replies", Boolean.toString(exclude_replies));
        params.put("limit", String.valueOf(limit));
        final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        String tag = sharedpreferences.getString(Helper.SET_FEATURED_TAG_ACTION, null);
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.MASTODON && tag != null) {
            params.put("tagged", tag.toLowerCase());
        }
        statuses = new ArrayList<>();

        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/accounts/%s/statuses", accountId)), 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
            setDefaultError(e);
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves accounts that reblogged the status *synchronously*
     *
     * @param statusId String Id of the status
     * @param max_id   String id max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getRebloggedBy(String statusId, String max_id) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        params.put("limit", "80");
        accounts = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/statuses/%s/reblogged_by", statusId)), 10, params, prefKeyOauthTokenT);
            accounts = parseAccountResponse(new JSONArray(response));
            setAccountsMaxId(httpsConnection, accounts);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Retrieves accounts that favourited the status *synchronously*
     *
     * @param statusId String Id of the status
     * @param max_id   String id max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getFavouritedBy(String statusId, String max_id) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        params.put("limit", "80");
        accounts = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/statuses/%s/favourited_by", statusId)), 10, params, prefKeyOauthTokenT);
            accounts = parseAccountResponse(new JSONArray(response));
            setAccountsMaxId(httpsConnection, accounts);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Retrieves one status *synchronously*
     *
     * @param statusId String Id of the status
     * @return APIResponse
     */
    public APIResponse getStatusbyId(String statusId) {
        statuses = new ArrayList<>();

        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/statuses/%s", statusId)), 10, null, prefKeyOauthTokenT);
            Status status = parseStatuses(context, new JSONObject(response));
            statuses.add(status);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves one status *synchronously*
     *
     * @param statusId String Id of the status
     * @return APIResponse
     */
    public APIResponse getStatusbyIdAndCache(String statusId) {
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/statuses/%s", statusId)), 10, null, prefKeyOauthTokenT);
            Status status = parseStatuses(context, new JSONObject(response));
            SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
            Account account = new AccountDAO(context, db).getAccountByToken(prefKeyOauthTokenT);
            new TimelineCacheDAO(context, db).update(status.getId(), response, account.getId(), account.getInstance());
            statuses.add(status);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves the context of status with replies *synchronously*
     *
     * @param statusId Id of the status
     * @return List<Status>
     */
    public app.fedilab.android.client.Entities.Context getStatusContext(String userId, String statusId) {
        app.fedilab.android.client.Entities.Context statusContext = new app.fedilab.android.client.Entities.Context();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response;
            if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                response = httpsConnection.get(getAbsoluteUrl(String.format("/statuses/%s/context", statusId)), 10, null, prefKeyOauthTokenT);
            } else {
                response = httpsConnection.get(getAbsoluteUr2l(String.format("/comments/%s/status/%s", userId, statusId)), 10, null, prefKeyOauthTokenT);
            }
            statusContext = parseContext(new JSONObject(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return statusContext;
    }

    public APIResponse getReplies(String statusId, String max_id) {
        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        params.put("limit", String.valueOf(30));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUr2l(String.format("/status/%s/replies", statusId)), 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves direct timeline for the account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getDirectTimeline(String max_id) {
        return getDirectTimeline(max_id, null, tootPerPage);
    }

    /**
     * Retrieves conversation timeline for the account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getConversationTimeline(String max_id) {
        return getConversationTimeline(max_id, null, tootPerPage);
    }

    /**
     * Retrieves direct timeline for the account since an Id value *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getConversationTimelineSinceId(String since_id) {
        return getConversationTimeline(null, since_id, tootPerPage);
    }

    /**
     * Retrieves conversation timeline for the account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    private APIResponse getConversationTimeline(String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 80)
            limit = 80;
        params.put("limit", String.valueOf(limit));
        List<Conversation> conversations = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/conversations"), 10, params, prefKeyOauthTokenT);
            apiResponse.setSince_id(httpsConnection.getSince_id());
            apiResponse.setMax_id(httpsConnection.getMax_id());
            conversations = parseConversations(new JSONArray(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setConversations(conversations);
        return apiResponse;
    }

    /**
     * Retrieves direct timeline for the account since an Id value *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getDirectTimelineSinceId(String since_id) {
        return getDirectTimeline(null, since_id, tootPerPage);
    }

    /**
     * Retrieves direct timeline for the account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    private APIResponse getDirectTimeline(String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 80)
            limit = 80;
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/timelines/direct"), 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves home timeline for the account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getHomeTimeline(String max_id) {
        return getHomeTimeline(max_id, null, null, tootPerPage);
    }

    /**
     * Retrieves home timeline for the account since an Id value *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getHomeTimelineSinceId(String since_id) {
        return getHomeTimeline(null, since_id, null, tootPerPage);
    }

    /**
     * Retrieves home timeline from cache the account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getHomeTimelineCache(String max_id) {

        SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
        statuses = new TimelineCacheDAO(context, db).get(max_id);

        SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        boolean remember_position_home = sharedpreferences.getBoolean(Helper.SET_REMEMBER_POSITION_HOME, true);
        if (remember_position_home) {
            if (statuses != null) {
                Iterator<Status> i = statuses.iterator();
                List<String> ids = new ArrayList<>();
                while (i.hasNext()) {
                    Status s = i.next();
                    if (ids.contains(s.getId())) {
                        i.remove();
                        new TimelineCacheDAO(context, db).remove(s.getId());
                    } else {
                        ids.add(s.getId());
                    }
                }
            }
            if (statuses == null || statuses.size() <= 1) {
                return getHomeTimeline(max_id);
            } else {
                if (statuses.get(0).getId().matches("\\d+")) {
                    apiResponse.setSince_id(String.valueOf(statuses.get(0).getId()));
                } else {
                    apiResponse.setSince_id(statuses.get(0).getId());
                }
                apiResponse.setMax_id(statuses.get(statuses.size() - 1).getId());
                apiResponse.setStatuses(statuses);
                return apiResponse;
            }
        } else {
            return getHomeTimeline(max_id);
        }

    }

    /**
     * Retrieves home timeline for the account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getHomeTimeline(String max_id, String since_id, String min_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (min_id != null)
            params.put("min_id", min_id);
        if (0 > limit || limit > 80)
            limit = 80;
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/timelines/home"), 10, params, prefKeyOauthTokenT);
            if (since_id == null) {
                statuses = parseStatusesForCache(context, new JSONArray(response));
            } else {
                statuses = parseStatuses(context, new JSONArray(response));
            }
            setStatusesMaxId(httpsConnection, statuses);
        } catch (UnknownHostException e) {
            if (since_id == null) {
                getHomeTimelineCache(max_id);
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        if (apiResponse == null)
            apiResponse = new APIResponse();
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Get identy proof for an account *synchronously*
     *
     * @param userId user_id String
     * @return APIResponse
     */
    public APIResponse getIdentityProof(String userId) {
        List<IdentityProof> identityProofs = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/accounts/%s/identity_proofs", userId)), 10, null, prefKeyOauthTokenT);

            identityProofs = parseIdentityProof(new JSONArray(response));
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        }
        if (apiResponse == null)
            apiResponse = new APIResponse();
        apiResponse.setIdentityProofs(identityProofs);
        return apiResponse;
    }

    /**
     * Retrieves public GNU timeline for the account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getGNUTimeline(String remoteInstance, String max_id) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get("https://" + remoteInstance + "/api/statuses/public_timeline.json", 10, params, prefKeyOauthTokenT);
            statuses = GNUAPI.parseStatuses(context, new JSONArray(response));
            if (statuses.size() > 0) {
                if (statuses.get(0).getId() != null && statuses.get(0).getId().matches("-?\\d+(\\.\\d+)?")) {
                    apiResponse.setSince_id(String.valueOf(statuses.get(0).getId()));
                    apiResponse.setMax_id(String.valueOf(statuses.get(statuses.size() - 1).getId()));
                } else {
                    apiResponse.setSince_id(statuses.get(0).getId());
                    apiResponse.setMax_id(statuses.get(statuses.size() - 1).getId());
                }
            }
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException | HttpsConnection.HttpsConnectionException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves public pixelfed timeline for the account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getPixelfedTimeline(String remoteInstance, String max_id) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("page", max_id);
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrlRemote(remoteInstance, "/timelines/public/"), 10, params, prefKeyOauthTokenT);

            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException | HttpsConnection.HttpsConnectionException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    private void setStatusesMaxId(HttpsConnection httpsConnection, List<Status> statuses) {
        if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            apiResponse.setSince_id(httpsConnection.getSince_id());
            apiResponse.setMax_id(httpsConnection.getMax_id());
        } else {
            if (statuses.size() > 0) {

                if (statuses.get(0).getId() != null && statuses.get(0).getId().matches("-?\\d+(\\.\\d+)?")) {
                    apiResponse.setSince_id(String.valueOf(statuses.get(0).getId()));
                    apiResponse.setMax_id(String.valueOf(statuses.get(statuses.size() - 1).getId()));
                } else {
                    apiResponse.setSince_id(statuses.get(0).getId());
                    apiResponse.setMax_id(statuses.get(statuses.size() - 1).getId());
                }
                if (statuses.size() < tootPerPage) {
                    apiResponse.setSince_id(null);
                    apiResponse.setMax_id(null);
                }
            }
        }
    }

    private void setNotificationsMaxId(HttpsConnection httpsConnection, List<Notification> notifications) {
        if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            apiResponse.setSince_id(httpsConnection.getSince_id());
            apiResponse.setMax_id(httpsConnection.getMax_id());
        } else {
            if (notifications.size() > 0) {
                if (notifications.get(0).getId() != null && notifications.get(0).getId().matches("-?\\d+(\\.\\d+)?")) {
                    apiResponse.setSince_id(String.valueOf(notifications.get(0).getId()));
                    apiResponse.setMax_id(String.valueOf(notifications.get(notifications.size() - 1).getId()));
                } else {
                    apiResponse.setSince_id(notifications.get(0).getId());
                    apiResponse.setMax_id(notifications.get(notifications.size() - 1).getId());
                }
            }
            if (notifications.size() < tootPerPage) {
                apiResponse.setSince_id(null);
                apiResponse.setMax_id(null);
            }
        }
    }

    private void setAccountsMaxId(HttpsConnection httpsConnection, List<Account> accounts) {
        if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            apiResponse.setSince_id(httpsConnection.getSince_id());
            apiResponse.setMax_id(httpsConnection.getMax_id());
        } else {
            if (accounts.size() > 0) {
                if (accounts.get(0).getId() != null && accounts.get(0).getId().matches("-?\\d+(\\.\\d+)?")) {
                    apiResponse.setSince_id(String.valueOf(accounts.get(0).getId()));
                    apiResponse.setMax_id(String.valueOf(accounts.get(accounts.size() - 1).getId()));
                } else {
                    apiResponse.setSince_id(accounts.get(0).getId());
                    apiResponse.setMax_id(accounts.get(accounts.size() - 1).getId());
                }
                if (accounts.size() < tootPerPage) {
                    apiResponse.setSince_id(null);
                    apiResponse.setMax_id(null);
                }
            }
        }
    }

    /**
     * Retrieves Peertube videos from an instance *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getPeertubeChannel(String instance, String name) {

        List<Account> accounts = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(String.format("https://" + instance + "/api/v1/accounts/%s/video-channels", name), 10, null, null);
            JSONArray jsonArray = new JSONObject(response).getJSONArray("data");
            accounts = parseAccountResponsePeertube(instance, jsonArray);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Retrieves Peertube videos from an instance *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getPeertubeChannelVideos(String instance, String name) {

        List<Peertube> peertubes = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(String.format("https://" + instance + "/api/v1/video-channels/%s/videos", name), 10, null, null);
            JSONArray jsonArray = new JSONObject(response).getJSONArray("data");
            peertubes = parsePeertube(instance, jsonArray);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setPeertubes(peertubes);
        return apiResponse;
    }

    /**
     * Retrieves Peertube videos from an instance *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getPeertube(String instance, String max_id) {

        List<Peertube> peertubes = new ArrayList<>();
        HashMap<String, String> params = new HashMap<>();
        if (max_id == null)
            max_id = "0";
        params.put("start", max_id);
        params.put("filter", "local");
        params.put("sort", "-publishedAt");
        params.put("count", "20");

        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get("https://" + instance + "/api/v1/videos", 10, params, null);
            if (response == null) {
                apiResponse.setPeertubes(peertubes);
                return apiResponse;
            }
            JSONObject jsonObject = new JSONObject(response);
            if (jsonObject.has("data")) {
                JSONArray jsonArray = new JSONObject(response).getJSONArray("data");
                peertubes = parsePeertube(instance, jsonArray);
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setPeertubes(peertubes);
        return apiResponse;
    }

    /**
     * Retrieves Peertube videos from an instance *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getSinglePeertube(String instance, String videoId) {


        Peertube peertube = null;
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(String.format("https://" + instance + "/api/v1/videos/%s", videoId), 10, null, null);
            JSONObject jsonObject = new JSONObject(response);
            peertube = parseSinglePeertube(instance, jsonObject);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        List<Peertube> peertubes = new ArrayList<>();
        peertubes.add(peertube);
        apiResponse.setPeertubes(peertubes);
        return apiResponse;
    }

    /**
     * Retrieves peertube search *synchronously*
     *
     * @param query String search
     * @return APIResponse
     */
    public APIResponse searchPeertube(String instance, String query) {
        HashMap<String, String> params = new HashMap<>();
        params.put("count", "50");
        if (query == null)
            return null;
        try {
            params.put("search", URLEncoder.encode(query, "UTF-8"));
        } catch (UnsupportedEncodingException e) {
            params.put("search", query);
        }

        List<Peertube> peertubes = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get("https://" + instance + "/api/v1/search/videos", 10, params, null);
            JSONArray jsonArray = new JSONObject(response).getJSONArray("data");
            peertubes = parsePeertube(instance, jsonArray);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setPeertubes(peertubes);
        return apiResponse;
    }

    /**
     * Retrieves Peertube videos from an instance *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getSinglePeertubeComments(String instance, String videoId) {
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(String.format("https://" + instance + "/api/v1/videos/%s/comment-threads", videoId), 10, null, null);
            JSONObject jsonObject = new JSONObject(response);
            statuses = parseSinglePeertubeComments(context, instance, jsonObject);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves home timeline for the account *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getHowTo() {

        List<HowToVideo> howToVideos = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get("https://peertube.fedilab.app/api/v1/video-channels/fedilab_channel/videos", 10, null, null);
            JSONArray jsonArray = new JSONObject(response).getJSONArray("data");
            howToVideos = parseHowTos(jsonArray);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setHowToVideos(howToVideos);
        return apiResponse;
    }

    /**
     * Retrieves Nitter timeline from accounts *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getNitter(String instance, String max_id) {

        final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        String nitterHost = sharedpreferences.getString(Helper.SET_NITTER_HOST, Helper.DEFAULT_NITTER_HOST).toLowerCase();
        String[] usernames = instance.split(" ");
        if (usernames.length == 0) {
            Error error = new Error();
            error.setError(context.getString(R.string.toast_error));
            error.setStatusCode(404);
            apiResponse.setError(error);
            return apiResponse;
        }
        StringBuilder urlparams = new StringBuilder();

        {
            int i = 0;
            while (i < usernames.length) {
                String username = usernames[i].trim();
                urlparams.append(username);
                if (i != usernames.length - 1) urlparams.append(",");
                i++;
            }
        }

        String url = "https://" + nitterHost + "/" + urlparams + "/rss";
        if (max_id != null) {
            url += "?max_position=" + max_id;
        }
        try {
            statuses = new ArrayList<>();
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(url, 30, null, null);
            apiResponse.setMax_id(httpsConnection.getMax_id());
            statuses = parseNitter(response);

        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves Misskey timeline from an instance *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getMisskey(String instance, String max_id) {

        JSONObject params = new JSONObject();
        try {
            params.put("file", false);
            if (max_id != null)
                params.put("untilId", max_id);
            params.put("local", true);
            params.put("poll", false);
            params.put("renote", false);
            params.put("reply", false);
        } catch (JSONException e) {
            e.printStackTrace();
        }

        try {
            statuses = new ArrayList<>();
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.postMisskey("https://" + instance + "/api/notes", 10, params, null);
            statuses = parseNotes(context, instance, new JSONArray(response));
            if (statuses.size() > 0) {
                apiResponse.setSince_id(statuses.get(0).getId());
                apiResponse.setMax_id(statuses.get(statuses.size() - 1).getId());
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves public timeline for the account *synchronously*
     *
     * @param local  boolean only local timeline
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getPublicTimeline(String instanceName, boolean local, String max_id) {
        return getPublicTimeline(local, instanceName, max_id, null, tootPerPage);
    }

    /**
     * Retrieves public timeline for the account *synchronously*
     *
     * @param local  boolean only local timeline
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getPublicTimeline(boolean local, String max_id) {
        return getPublicTimeline(local, null, max_id, null, tootPerPage);
    }

    /**
     * Retrieves public timeline for the account since an Id value *synchronously*
     *
     * @param local    boolean only local timeline
     * @param since_id String id since
     * @return APIResponse
     */
    public APIResponse getPublicTimelineSinceId(boolean local, String since_id) {
        return getPublicTimeline(local, null, null, since_id, tootPerPage);
    }

    /**
     * Retrieves instance timeline since an Id value *synchronously*
     *
     * @param instanceName String instance name
     * @param since_id     String id since
     * @return APIResponse
     */
    public APIResponse getInstanceTimelineSinceId(String instanceName, String since_id) {
        return getPublicTimeline(true, instanceName, null, since_id, tootPerPage);
    }

    /**
     * Retrieves public timeline for the account *synchronously*
     *
     * @param local    boolean only local timeline
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    private APIResponse getPublicTimeline(boolean local, String instanceName, String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (local)
            params.put("local", Boolean.toString(true));
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String url;
            if (instanceName == null)
                url = getAbsoluteUrl("/timelines/public");
            else
                url = getAbsoluteUrlRemoteInstance(instanceName);
            String response = httpsConnection.get(url, 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves news coming from Fedilab's account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getNews(String max_id) {

        HashMap<String, String> params = null;
        if (max_id != null) {
            params = new HashMap<>();
            params.put("max_id", max_id);
        }

        statuses = new ArrayList<>();
        apiResponse = new APIResponse();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get("https://toot.fedilab.app/api/v1/timelines/tag/fedilab", 10, params, prefKeyOauthTokenT);
            List<Status> tmp_status = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, tmp_status);
            if (tmp_status.size() > 0) {
                for (Status status : tmp_status) {
                    if (status.getAccount().getAcct().equals("apps")) {
                        statuses.add(status);
                    }
                }
            }
        } catch (IOException | NoSuchAlgorithmException | KeyManagementException | HttpsConnection.HttpsConnectionException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves discover timeline for the account *synchronously*
     *
     * @param local  boolean only local timeline
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getDiscoverTimeline(boolean local, String max_id) {
        return getDiscoverTimeline(local, max_id, null, tootPerPage);
    }

    /**
     * Retrieves discover timeline for the account *synchronously*
     *
     * @param local    boolean only local timeline
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getDiscoverTimeline(boolean local, String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (local)
            params.put("local", Boolean.toString(true));
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String url;
            url = getAbsoluteUr2l("/discover/posts");
            String response = httpsConnection.get(url, 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    public APIResponse getCustomArtTimeline(boolean local, String tag, String max_id, List<String> any, List<String> all, List<String> none) {
        return getArtTimeline(local, tag, max_id, null, any, all, none);
    }

    public APIResponse getArtTimeline(boolean local, String max_id, List<String> any, List<String> all, List<String> none) {
        return getArtTimeline(local, null, max_id, null, any, all, none);
    }

    public APIResponse getCustomArtTimelineSinceId(boolean local, String tag, String since_id, List<String> any, List<String> all, List<String> none) {
        return getArtTimeline(local, tag, null, since_id, any, all, none);
    }

    public APIResponse getArtTimelineSinceId(boolean local, String since_id, List<String> any, List<String> all, List<String> none) {
        return getArtTimeline(local, null, null, since_id, any, all, none);
    }

    /**
     * Retrieves art timeline
     *
     * @param local  boolean only local timeline
     * @param max_id String id max
     * @return APIResponse
     */
    private APIResponse getArtTimeline(boolean local, String tag, String max_id, String since_id, List<String> any, List<String> all, List<String> none) {
        if (tag == null)
            tag = "mastoart";
        APIResponse apiResponse = getPublicTimelineTag(tag, local, true, max_id, since_id, tootPerPage, any, all, none, null);
        APIResponse apiResponseReply = new APIResponse();
        if (apiResponse != null) {
            apiResponseReply.setMax_id(apiResponse.getMax_id());
            apiResponseReply.setSince_id(apiResponse.getSince_id());
            apiResponseReply.setStatuses(new ArrayList<>());
            if (apiResponse.getStatuses() != null && apiResponse.getStatuses().size() > 0) {
                for (Status status : apiResponse.getStatuses()) {
                    if (status.getMedia_attachments() != null) {
                        try {
                            String statusSerialized = Helper.statusToStringStorage(status);
                            for (Attachment attachment : status.getMedia_attachments()) {
                                Status newStatus = Helper.restoreStatusFromString(statusSerialized);
                                if (newStatus == null)
                                    break;
                                newStatus.setArt_attachment(attachment);
                                apiResponseReply.getStatuses().add(newStatus);
                            }
                        } catch (Exception ignored) {
                        }
                    }
                }
            }
        }
        return apiResponseReply;
    }

    /**
     * Retrieves public tag timeline *synchronously*
     *
     * @param tag    String
     * @param local  boolean only local timeline
     * @param max_id String id max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getPublicTimelineTag(String tag, boolean local, String max_id, List<String> any, List<String> all, List<String> none) {
        return getPublicTimelineTag(tag, local, false, max_id, null, tootPerPage, any, all, none, null);
    }

    /**
     * Retrieves public tag timeline *synchronously*
     *
     * @param tag    String
     * @param local  boolean only local timeline
     * @param max_id String id max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getPublicTimelineTag(String tag, boolean local, String max_id, String instance) {
        return getPublicTimelineTag(tag, local, false, max_id, null, tootPerPage, null, null, null, instance);
    }

    /**
     * Retrieves public tag timeline *synchronously*
     *
     * @param tag      String
     * @param local    boolean only local timeline
     * @param since_id String since id
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getPublicTimelineTagSinceId(String tag, boolean local, String since_id, List<String> any, List<String> all, List<String> none) {
        return getPublicTimelineTag(tag, local, false, null, since_id, tootPerPage, any, all, none, null);
    }

    /**
     * Retrieves public tag timeline *synchronously*
     *
     * @param tag      String
     * @param local    boolean only local timeline
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getPublicTimelineTag(String tag, boolean local, boolean onlymedia, String max_id, String since_id, int limit, List<String> any, List<String> all, List<String> none, String instance) {

        HashMap<String, String> params = new HashMap<>();
        if (local)
            params.put("local", Boolean.toString(true));
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        if (onlymedia)
            params.put("only_media", Boolean.toString(true));


        if (any != null && any.size() > 0) {
            StringBuilder parameters = new StringBuilder();
            for (String a : any) {
                try {
                    a = URLEncoder.encode(a, "UTF-8");
                } catch (UnsupportedEncodingException ignored) {
                }
                parameters.append("any[]=").append(a).append("&");
            }
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(6));
            params.put("any[]", parameters.toString());
        }
        if (all != null && all.size() > 0) {
            StringBuilder parameters = new StringBuilder();
            for (String a : all) {
                try {
                    a = URLEncoder.encode(a, "UTF-8");
                } catch (UnsupportedEncodingException ignored) {
                }
                parameters.append("all[]=").append(a).append("&");
            }
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(6));
            params.put("all[]", parameters.toString());
        }
        if (none != null && none.size() > 0) {
            StringBuilder parameters = new StringBuilder();
            for (String a : none) {
                try {
                    a = URLEncoder.encode(a, "UTF-8");
                } catch (UnsupportedEncodingException ignored) {
                }
                parameters.append("none[]=").append(a).append("&");
            }
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(7));
            params.put("none[]", parameters.toString());
        }
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        if (tag == null)
            return null;
        try {
            String query = tag.trim();
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PEERTUBE)
                try {
                    query = URLEncoder.encode(query, "UTF-8");
                } catch (UnsupportedEncodingException ignored) {
                }
            String response;
            if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                if (instance == null)
                    response = httpsConnection.get(getAbsoluteUrl(String.format("/timelines/tag/%s", query)), 10, params, prefKeyOauthTokenT);
                else
                    response = httpsConnection.get(getAbsoluteUrlRemote(instance, String.format("/timelines/tag/%s", query)), 10, params, null);
                statuses = parseStatuses(context, new JSONArray(response));
            } else {
                //Parse for pixelfed
                params = new HashMap<>();
                params.put("hashtag", tag);
                response = httpsConnection.get(getAbsoluteUr2l("/discover/tag"), 10, params, null);
                JSONArray tags = new JSONObject(response).getJSONArray("tags");
                statuses = new ArrayList<>();
                for (int i = 0; i < tags.length(); i++) {
                    Status status = parseStatuses(context, tags.getJSONObject(i).getJSONObject("status"));
                    statuses.add(status);
                }
            }

            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves muted users by the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getMuted(String max_id) {
        return getAccounts("/mutes", max_id, null, accountPerPage);
    }

    /**
     * Retrieves blocked users by the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getBlocks(String max_id) {
        return getAccounts("/blocks", max_id, null, accountPerPage);
    }

    /**
     * Retrieves following for the account specified by targetedId  *synchronously*
     *
     * @param targetedId String targetedId
     * @param max_id     String id max
     * @return APIResponse
     */
    public APIResponse getFollowing(String targetedId, String max_id) {
        return getAccounts(String.format("/accounts/%s/following", targetedId), max_id, null, accountPerPage);
    }

    /**
     * Retrieves followers for the account specified by targetedId  *synchronously*
     *
     * @param targetedId String targetedId
     * @param max_id     String id max
     * @return APIResponse
     */
    public APIResponse getFollowers(String targetedId, String max_id) {
        return getAccounts(String.format("/accounts/%s/followers", targetedId), max_id, null, accountPerPage);
    }

    /**
     * Retrieves blocked users by the authenticated account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getAccounts(String action, String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        params.put("limit", String.valueOf(limit));
        accounts = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(action), 10, params, prefKeyOauthTokenT);
            accounts = parseAccountResponse(new JSONArray(response));
            setAccountsMaxId(httpsConnection, accounts);
            if (accounts.size() == 1) {
                if (accounts.get(0).getAcct() == null) {
                    Throwable error = new Throwable(context.getString(R.string.toast_error));
                    setError(500, error);
                }
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Retrieves blocked domains for the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getBlockedDomain(String max_id) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        params.put("limit", "80");
        domains = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/domain_blocks"), 10, params, prefKeyOauthTokenT);
            apiResponse.setSince_id(httpsConnection.getSince_id());
            apiResponse.setMax_id(httpsConnection.getMax_id());
            domains = parseDomains(new JSONArray(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setDomains(domains);
        return apiResponse;
    }

    /**
     * Delete a blocked domains for the authenticated account *synchronously*
     *
     * @param domain String domain name
     */
    @SuppressWarnings("SameParameterValue")
    public int deleteBlockedDomain(String domain) {

        HashMap<String, String> params = new HashMap<>();
        params.put("domain", domain);
        domains = new ArrayList<>();
        HttpsConnection httpsConnection;
        try {
            httpsConnection = new HttpsConnection(context, this.instance);
            httpsConnection.delete(getAbsoluteUrl("/domain_blocks"), 10, params, prefKeyOauthTokenT);
            actionCode = httpsConnection.getActionCode();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return actionCode;
    }

    /**
     * Retrieves follow requests for the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getFollowRequest(String max_id) {
        return getFollowRequest(max_id, null, accountPerPage);
    }

    /**
     * Retrieves follow requests for the authenticated account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getFollowRequest(String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        params.put("limit", String.valueOf(limit));
        accounts = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/follow_requests"), 10, params, prefKeyOauthTokenT);
            accounts = parseAccountResponse(new JSONArray(response));
            setAccountsMaxId(httpsConnection, accounts);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Retrieves favourited status for the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getFavourites(String max_id) {
        return getFavourites(max_id, null, tootPerPage);
    }

    /**
     * Retrieves favourited status for the authenticated account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    private APIResponse getFavourites(String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 40)
            limit = 40;
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/favourites"), 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Retrieves announcements for the authenticated account *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getAnnouncements() {

        List<Announcement> announcements = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/announcements"), 10, null, prefKeyOauthTokenT);
            announcements = parseAnnouncement(context, new JSONArray(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAnnouncements(announcements);
        return apiResponse;
    }


    /**
     * Retrieves bookmarked status for the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getBookmarks(String max_id) {

        HashMap<String, String> params = new HashMap<>();
        statuses = new ArrayList<>();
        try {
            String response;
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                if (max_id != null)
                    params.put("max_id", max_id);
                params.put("limit", "40");
                response = httpsConnection.get(getAbsoluteUrl("/bookmarks"), 10, params, prefKeyOauthTokenT);
            } else {
                params.put("max_id", max_id);
                params.put("limit", String.valueOf(tootPerPage));
                response = httpsConnection.get(Helper.instanceWithProtocol(this.context, this.instance) + "/api/local/bookmarks", 10, params, prefKeyOauthTokenT);
            }

            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Makes the post action for a status
     *
     * @param statusAction Enum
     * @param targetedId   String id of the targeted Id *can be this of a status or an account*
     * @return in status code - Should be equal to 200 when action is done
     */
    public int postAction(StatusAction statusAction, String targetedId) {
        return postAction(statusAction, targetedId, null, null);
    }

    /**
     * Makes the post action for a status
     *
     * @param statusAction Enum
     * @param targetedId   String id of the targeted Id *can be this of a status or an account*
     * @return in status code - Should be equal to 200 when action is done
     */
    public int postAction(StatusAction statusAction, String targetedId, String comment) {
        return postAction(statusAction, targetedId, null, comment);
    }

    /**
     * Makes the post action for a status
     *
     * @param targetedId        String id of the targeted Id *can be this of a status or an account*
     * @param muteNotifications - boolean - notifications should be also muted
     * @return in status code - Should be equal to 200 when action is done
     */
    public int muteNotifications(String targetedId, boolean muteNotifications) {

        HashMap<String, String> params = new HashMap<>();
        params.put("notifications", Boolean.toString(muteNotifications));
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            httpsConnection.post(getAbsoluteUrl(String.format("/accounts/%s/mute", targetedId)), 10, params, prefKeyOauthTokenT);
            actionCode = httpsConnection.getActionCode();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return actionCode;
    }

    //Pleroma admin calls

    /**
     * Makes the post action
     *
     * @param status  Status object related to the status
     * @param comment String comment for the report
     * @return in status code - Should be equal to 200 when action is done
     */
    public int reportAction(Status status, String comment) {
        return postAction(API.StatusAction.REPORT, null, status, comment);
    }

    /**
     * Makes the post action
     *
     * @param targetedId targeted account
     * @param comment    String comment for the report
     * @return in status code - Should be equal to 200 when action is done
     */
    public int reportAction(String targetedId, String comment) {
        return postAction(API.StatusAction.REPORT, targetedId, null, comment);
    }

    public int statusAction(Status status) {
        return postAction(StatusAction.CREATESTATUS, null, status, null);
    }

    /**
     * Makes the post action
     *
     * @param statusAction Enum
     * @param targetedId   String id of the targeted Id *can be this of a status or an account*
     * @param status       Status object related to the status
     * @param comment      String comment for the report
     * @return in status code - Should be equal to 200 when action is done
     */
    private int postAction(StatusAction statusAction, String targetedId, Status status, String comment) {
        String action;
        HashMap<String, String> params = null;
        switch (statusAction) {
            case FAVOURITE:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s/favourite", targetedId);
                } else {
                    action = "/i/like";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case UNFAVOURITE:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s/unfavourite", targetedId);
                } else {
                    action = "/i/like";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case BOOKMARK:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s/bookmark", targetedId);
                } else {
                    action = "/i/bookmark";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case UNBOOKMARK:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s/unbookmark", targetedId);
                } else {
                    action = "/i/bookmark";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case REBLOG:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s/reblog", targetedId);
                } else {
                    action = "/i/share";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case UNREBLOG:

                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s/unreblog", targetedId);
                } else {
                    action = "/i/share";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case FOLLOW:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/accounts/%s/follow", targetedId);
                } else {
                    action = "/i/follow";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case NOTIFY_FOR_ACCOUNT:
                params = new HashMap<>();
                params.put("notify", "true");
                action = String.format("/accounts/%s/follow", targetedId);
                break;
            case UNNOTIFY_FOR_ACCOUNT:
                params = new HashMap<>();
                params.put("notify", "false");
                action = String.format("/accounts/%s/follow", targetedId);
                break;
            case REMOTE_FOLLOW:
                action = "/follows";
                params = new HashMap<>();
                params.put("uri", targetedId);
                break;
            case UNFOLLOW:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/accounts/%s/unfollow", targetedId);
                } else {
                    action = "/i/follow";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case BLOCK:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/accounts/%s/block", targetedId);
                } else {
                    action = "/i/block";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                }
                break;
            case BLOCK_DOMAIN:
                action = "/domain_blocks";
                params = new HashMap<>();
                params.put("domain", targetedId);
                break;
            case UNBLOCK:
                action = String.format("/accounts/%s/unblock", targetedId);
                break;
            case MUTE:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/accounts/%s/mute", targetedId);
                } else {
                    action = "/i/mute";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                    params.put("type", "user");
                }
                break;
            case UNMUTE:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/accounts/%s/unmute", targetedId);
                } else {
                    action = "/i/unmute";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                    params.put("type", "user");
                }
                break;
            case MUTE_CONVERSATION:
                action = String.format("/statuses/%s/mute", targetedId);
                break;
            case UNMUTE_CONVERSATION:
                action = String.format("/statuses/%s/unmute", targetedId);
                break;
            case PIN:
                action = String.format("/statuses/%s/pin", targetedId);
                break;
            case UNPIN:
                action = String.format("/statuses/%s/unpin", targetedId);
                break;
            case REACT:
                action = String.format("/pleroma/statuses/%s/react_with_emoji", targetedId);
                break;
            case UNREACT:
                action = String.format("/pleroma/statuses/%s/unreact_with_emoji", targetedId);
                break;
            case ENDORSE:
                action = String.format("/accounts/%s/pin", targetedId);
                break;
            case UNENDORSE:
                action = String.format("/accounts/%s/unpin", targetedId);
                break;
            case SHOW_BOOST:
                params = new HashMap<>();
                params.put("reblogs", "true");
                action = String.format("/accounts/%s/follow", targetedId);
                break;
            case HIDE_BOOST:
                params = new HashMap<>();
                params.put("reblogs", "false");
                action = String.format("/accounts/%s/follow", targetedId);
                break;
            case UNSTATUS:
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    action = String.format("/statuses/%s", targetedId);
                } else {
                    action = "/i/delete";
                    params = new HashMap<>();
                    params.put("item", targetedId);
                    params.put("type", "status");
                }
                break;
            case REMOVE_REACTION:
            case ADD_REACTION:
                action = String.format("/announcements/%s/reactions/%s", targetedId, comment);
                break;
            case REMOVE_PLEROMA_REACTION:
            case ADD_PLEROMA_REACTION:
                action = String.format("/pleroma/statuses/%s/reactions/%s", targetedId, comment);
                break;
            case DISMISS_ANNOUNCEMENT:
                action = String.format("/announcements/%s/dismiss", targetedId);
                break;
            case AUTHORIZE:
                action = String.format("/follow_requests/%s/authorize", targetedId);
                break;
            case REJECT:
                action = String.format("/follow_requests/%s/reject", targetedId);
                break;
            case REPORT:
                action = "/reports";
                params = new HashMap<>();
                if (status != null)
                    params.put("account_id", status.getAccount().getId());
                else
                    params.put("account_id", targetedId);
                params.put("comment", comment);
                if (status != null) {
                    params.put("status_ids[]", status.getId());
                }
                break;
            case CREATESTATUS:
                params = new HashMap<>();
                action = "/statuses";
                try {
                    params.put("status", URLEncoder.encode(status.getContent(), "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    params.put("status", status.getContent());
                }
                if (status.getScheduled_at() != null)
                    params.put("scheduled_at", status.getScheduled_at());
                if (status.getIn_reply_to_id() != null)
                    params.put("in_reply_to_id", status.getIn_reply_to_id());
                if (status.getMedia_attachments() != null && status.getMedia_attachments().size() > 0) {
                    StringBuilder parameters = new StringBuilder();
                    for (Attachment attachment : status.getMedia_attachments())
                        parameters.append("media_ids[]=").append(attachment.getId()).append("&");
                    parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(12));
                    params.put("media_ids[]", parameters.toString());
                }
                if (status.isSensitive())
                    params.put("sensitive", Boolean.toString(status.isSensitive()));
                if (status.getSpoiler_text() != null)
                    try {
                        params.put("spoiler_text", URLEncoder.encode(status.getSpoiler_text(), "UTF-8"));
                    } catch (UnsupportedEncodingException e) {
                        params.put("spoiler_text", status.getSpoiler_text());
                    }
                params.put("visibility", status.getVisibility());
                break;
            default:
                return -1;
        }

        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED || (statusAction != StatusAction.UNSTATUS
                && statusAction != StatusAction.ADD_REACTION && statusAction != StatusAction.REMOVE_REACTION
                && statusAction != StatusAction.ADD_PLEROMA_REACTION && statusAction != StatusAction.REMOVE_PLEROMA_REACTION)) {
            try {
                HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
                String url;
                if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    url = getAbsoluteUrl(action);
                } else {
                    url = "https://" + Helper.getLiveInstance(context) + action;
                }
                String resp = httpsConnection.post(url, 10, params, prefKeyOauthTokenT);
                actionCode = httpsConnection.getActionCode();
                Bundle b = new Bundle();
                try {
                    Status status1 = parseStatuses(context, new JSONObject(resp));
                    b.putParcelable("status", status1);
                } catch (JSONException ignored) {
                }
                Intent intentBC = new Intent(Helper.RECEIVE_ACTION);
                intentBC.putExtras(b);
                LocalBroadcastManager.getInstance(context).sendBroadcast(intentBC);
                SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
                Account account = new AccountDAO(context, db).getAccountByToken(prefKeyOauthTokenT);
                Status indb = new TimelineCacheDAO(context, db).getSingle(targetedId);
                if (indb != null && MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                    String response = httpsConnection.get(getAbsoluteUrl(String.format("/statuses/%s", targetedId)), 10, null, prefKeyOauthTokenT);
                    new TimelineCacheDAO(context, db).update(targetedId, response, account.getId(), account.getInstance());
                }
            } catch (HttpsConnection.HttpsConnectionException e) {
                setError(e.getStatusCode(), e);
                e.printStackTrace();
            } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
                e.printStackTrace();
            }
        } else if (statusAction == StatusAction.ADD_REACTION || statusAction == StatusAction.ADD_PLEROMA_REACTION) {
            try {
                HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
                httpsConnection.put(getAbsoluteUrl(action), 10, null, prefKeyOauthTokenT);
                actionCode = httpsConnection.getActionCode();
            } catch (HttpsConnection.HttpsConnectionException e) {
                setError(e.getStatusCode(), e);
            } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
                e.printStackTrace();
            }
        } else {
            try {
                HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
                httpsConnection.delete(getAbsoluteUrl(action), 10, null, prefKeyOauthTokenT);
                actionCode = httpsConnection.getActionCode();
                //Delete a status (Mastodon or Pleroma)
                if (statusAction != StatusAction.REMOVE_REACTION && statusAction != StatusAction.REMOVE_PLEROMA_REACTION) {
                    SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
                    new TimelineCacheDAO(context, db).remove(targetedId);
                }
            } catch (HttpsConnection.HttpsConnectionException e) {
                setError(e.getStatusCode(), e);
            } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
                e.printStackTrace();
            }
        }
        return actionCode;
    }

    public int reportStatus(List<Status> statuses, String comment, boolean forward) {
        String action;
        HashMap<String, String> params;
        action = "/reports";
        params = new HashMap<>();
        params.put("account_id", statuses.get(0).getAccount().getId());
        params.put("comment", comment);
        StringBuilder parameters = new StringBuilder();
        for (Status val : statuses)
            parameters.append("status_ids[]=").append(val).append("&");
        if (parameters.length() > 0) {
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(13));
            params.put("status_ids[]", parameters.toString());
        }
        params.put("forward", String.valueOf(forward));
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            httpsConnection.post(getAbsoluteUrl(action), 10, params, prefKeyOauthTokenT);
            actionCode = httpsConnection.getActionCode();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return actionCode;
    }

    /**
     * scheduled action for a status
     *
     * @param status Status object related to the status
     * @return APIResponse
     */
    public APIResponse scheduledAction(String call, Status status, String max_id, String targetedId) {

        HashMap<String, String> params = new HashMap<>();
        if (call.equals("PUT")) {
            if (status.getScheduled_at() != null)
                params.put("scheduled_at", status.getScheduled_at());
        } else if (call.equals("GET")) {
            if (max_id != null)
                params.put("max_id", max_id);
        }
        List<StoredStatus> storedStatus = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = null;

            switch (call) {
                case "GET":
                    response = httpsConnection.get(getAbsoluteUrl("/scheduled_statuses/"), 10, null, prefKeyOauthTokenT);
                    break;
                case "PUT":
                    response = httpsConnection.put(getAbsoluteUrl(String.format("/scheduled_statuses/%s", targetedId)), 10, params, prefKeyOauthTokenT);
                    break;
                case "DELETE":
                    httpsConnection.delete(getAbsoluteUrl(String.format("/scheduled_statuses/%s", targetedId)), 10, null, prefKeyOauthTokenT);
                    break;
            }
            if (call.equals("GET")) {
                apiResponse.setSince_id(httpsConnection.getSince_id());
                apiResponse.setMax_id(httpsConnection.getMax_id());
            }
            if (response != null && call.equals("PUT")) {
                Schedule schedule = parseSimpleSchedule(context, new JSONObject(response));
                StoredStatus st = new StoredStatus();
                st.setCreation_date(status.getCreated_at());
                st.setId(-1);
                st.setJobId(-1);
                st.setScheduled_date(schedule.getScheduled_at());
                st.setStatusReply(null);
                st.setSent_date(null);
                final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
                String userId = sharedpreferences.getString(Helper.PREF_KEY_ID, null);
                st.setUserId(userId);
                st.setStatus(schedule.getStatus());
                storedStatus.add(st);
            } else if (response != null) {
                List<Schedule> scheduleList = parseSchedule(context, new JSONArray(response));
                SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
                String userId = sharedpreferences.getString(Helper.PREF_KEY_ID, null);
                for (Schedule schedule : scheduleList) {
                    StoredStatus st = new StoredStatus();
                    st.setCreation_date(null);
                    st.setScheduledServerdId(schedule.getId());
                    st.setJobId(-1);
                    st.setScheduled_date(schedule.getScheduled_at());
                    st.setStatusReply(null);
                    st.setSent_date(null);
                    st.setUserId(userId);
                    st.setStatus(schedule.getStatus());
                    storedStatus.add(st);
                }
            }

        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStoredStatuses(storedStatus);
        return apiResponse;
    }

    /**
     * Public api call to submit a vote
     *
     * @param pollId  String
     * @param choices int[]
     * @return Poll
     */
    public Poll submiteVote(String pollId, int[] choices) {
        JsonObject jsonObject = new JsonObject();
        JsonArray jchoices = new JsonArray();
        for (int choice : choices) {
            jchoices.add(choice);
        }
        jsonObject.add("choices", jchoices);
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.postJson(getAbsoluteUrl(String.format("/polls/%s/votes", pollId)), 10, jsonObject, prefKeyOauthTokenT);
            return parsePoll(new JSONObject(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Public api call to refresh a poll
     *
     * @param status Status
     * @return Poll
     */
    public Poll getPoll(Status status) {
        try {
            Poll _p = (status.getReblog() != null) ? status.getReblog().getPoll() : status.getPoll();
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/polls/%s", _p.getId())), 10, null, prefKeyOauthTokenT);
            Poll poll = parsePoll(new JSONObject(response));
            Bundle b = new Bundle();
            status.setPoll(poll);
            b.putParcelable("status", status);
            Intent intentBC = new Intent(Helper.RECEIVE_ACTION);
            intentBC.putExtras(b);
            SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
            Status alreadyCached = new TimelineCacheDAO(context, db).getSingle(status.getId());
            Account account = new AccountDAO(context, db).getAccountByToken(prefKeyOauthTokenT);
            if (alreadyCached != null) {
                poll = parsePoll(new JSONObject(response));
                status.setPoll(poll);
                new TimelineCacheDAO(context, db).update(status.getId(), Helper.statusToStringStorage(status), account.getId(), account.getInstance());
            }
            LocalBroadcastManager.getInstance(context).sendBroadcast(intentBC);
            return poll;
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Posts a status
     *
     * @param status Status object related to the status
     * @return APIResponse
     */
    public APIResponse postStatusAction(Status status) {

        JsonObject jsonObject = new JsonObject();
        String url;
        url = getAbsoluteUrl("/statuses");

        if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            jsonObject.addProperty("status", status.getContent());
            if (status.getContentType() != null)
                jsonObject.addProperty("content_type", status.getContentType());
            if (status.getIn_reply_to_id() != null)
                jsonObject.addProperty("in_reply_to_id", status.getIn_reply_to_id());
            if (status.getMedia_attachments() != null && status.getMedia_attachments().size() > 0) {
                JsonArray mediaArray = new JsonArray();
                for (Attachment attachment : status.getMedia_attachments())
                    mediaArray.add(attachment.getId());
                jsonObject.add("media_ids", mediaArray);
            }
            if (status.getScheduled_at() != null)
                jsonObject.addProperty("scheduled_at", status.getScheduled_at());
            if (status.isSensitive())
                jsonObject.addProperty("sensitive", status.isSensitive());
            if (status.getSpoiler_text() != null)
                jsonObject.addProperty("spoiler_text", status.getSpoiler_text());

            if (status.getPoll() != null) {
                JsonObject poll = new JsonObject();
                JsonArray options = new JsonArray();
                for (PollOptions option : status.getPoll().getOptionsList()) {
                    if (!option.getTitle().isEmpty())
                        options.add(option.getTitle());
                }
                poll.add("options", options);
                poll.addProperty("expires_in", status.getPoll().getExpires_in());
                poll.addProperty("multiple", status.getPoll().isMultiple());
                jsonObject.add("poll", poll);
            }
            jsonObject.addProperty("visibility", status.getVisibility());
        } else {
            if (status.getIn_reply_to_id() != null) {
                url = "https://" + Helper.getLiveInstance(context) + "/i/comment";
                jsonObject.addProperty("comment", status.getContent());
                jsonObject.addProperty("item", status.getIn_reply_to_id());
                jsonObject.addProperty("sensitive", status.isSensitive());
            } else {
                url = "https://" + Helper.getLiveInstance(context) + "/api/compose/v0/publish";
                jsonObject.addProperty("caption", status.getContent());
                jsonObject.addProperty("comments_disabled", false);
                jsonObject.addProperty("cw", status.isSensitive());
                jsonObject.addProperty("visibility", status.getVisibility());
                String attachments = new GsonBuilder().serializeNulls().create().toJson(status.getMedia_attachments());
                jsonObject.addProperty("place", false);

                JsonParser parser = new JsonParser();
                JsonArray jsonArrayTags = parser.parse("[]").getAsJsonArray();

                jsonObject.add("tagged", jsonArrayTags);
                JsonArray jsonArrayMedia = parser.parse(attachments).getAsJsonArray();
                jsonObject.add("media", jsonArrayMedia);
            }
        }
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.postJson(url, 10, jsonObject, prefKeyOauthTokenT);
            if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                Status statusreturned = parseStatuses(context, new JSONObject(response));
                statuses.add(statusreturned);
            } else {
                final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
                SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
                String userId = sharedpreferences.getString(Helper.PREF_KEY_ID, null);
                String instance = sharedpreferences.getString(Helper.PREF_INSTANCE, Helper.getLiveInstance(context));
                Account account = new AccountDAO(context, db).getUniqAccount(userId, instance);
                status.setAccount(account);
                statuses.add(status);
            }
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
            setDefaultError(e);
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Posts a status
     *
     * @param notificationId String, the current notification id, if null all notifications are deleted
     * @return APIResponse
     */
    public APIResponse postNoticationAction(String notificationId) {

        String action;
        HashMap<String, String> params = new HashMap<>();
        if (notificationId == null)
            action = "/notifications/clear";
        else {
            action = "/notifications/" + notificationId + "/dismiss";
        }
        try {
            new HttpsConnection(context, this.instance).post(getAbsoluteUrl(action), 10, params, prefKeyOauthTokenT);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Retrieves notifications for the authenticated account since an id*synchronously*
     *
     * @param since_id String since max
     * @return APIResponse
     */
    public APIResponse getNotificationsSince(DisplayNotificationsFragment.Type type, String since_id, boolean display) {
        return getNotifications(type, null, since_id, notificationPerPage, display);
    }

    /**
     * Retrieves notifications for the authenticated account since an id*synchronously*
     *
     * @param since_id String since max
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getNotificationsSince(DisplayNotificationsFragment.Type type, String since_id, int notificationPerPage, boolean display) {
        return getNotifications(type, null, since_id, notificationPerPage, display);
    }

    /**
     * Retrieves notifications for the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getNotifications(DisplayNotificationsFragment.Type type, String max_id, boolean display) {
        return getNotifications(type, max_id, null, notificationPerPage, display);
    }

    /**
     * Retrieves notifications for the authenticated account *synchronously*
     *
     * @param max_id String id max
     * @return APIResponse
     */
    public APIResponse getNotifications(String max_id) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        params.put("limit", "30");
        if (context == null) {
            apiResponse = new APIResponse();
            Error error = new Error();
            apiResponse.setError(error);
            return apiResponse;
        }
        List<Notification> notifications = new ArrayList<>();

        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/notifications"), 15, params, prefKeyOauthTokenT);
            notifications = parseNotificationResponse(new JSONArray(response));
            setNotificationsMaxId(httpsConnection, notifications);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setNotifications(notifications);
        return apiResponse;
    }

    /**
     * Retrieves notifications for the authenticated account *synchronously*
     *
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    private APIResponse getNotifications(DisplayNotificationsFragment.Type type, String max_id, String since_id, int limit, boolean display) {

        HashMap<String, String> params = new HashMap<>();
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            params.put("pg", "true");
            params.put("page", max_id);
        } else {
            if (max_id != null)
                params.put("max_id", max_id);
            if (since_id != null)
                params.put("since_id", since_id);
            if (0 > limit || limit > 30)
                limit = 30;
            params.put("limit", String.valueOf(limit));
        }

        if (context == null) {
            apiResponse = new APIResponse();
            Error error = new Error();
            apiResponse.setError(error);
            return apiResponse;
        }
        final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        boolean notif_follow, notif_add, notif_mention, notif_share, notif_poll, notif_status;
        StringBuilder parameters = new StringBuilder();
        //TODO: If pixelfed supports exclude_types this condition needs to be changed
        if (type == DisplayNotificationsFragment.Type.ALL && MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
            if (display) {
                notif_follow = sharedpreferences.getBoolean(Helper.SET_NOTIF_FOLLOW_FILTER, true);
                notif_add = sharedpreferences.getBoolean(Helper.SET_NOTIF_ADD_FILTER, true);
                notif_mention = sharedpreferences.getBoolean(Helper.SET_NOTIF_MENTION_FILTER, true);
                notif_share = sharedpreferences.getBoolean(Helper.SET_NOTIF_SHARE_FILTER, true);
                notif_poll = sharedpreferences.getBoolean(Helper.SET_NOTIF_POLL_FILTER, true);
                notif_status = sharedpreferences.getBoolean(Helper.SET_NOTIF_STATUS_FILTER, true);
            } else {
                notif_follow = sharedpreferences.getBoolean(Helper.SET_NOTIF_FOLLOW, true);
                notif_add = sharedpreferences.getBoolean(Helper.SET_NOTIF_ADD, true);
                notif_mention = sharedpreferences.getBoolean(Helper.SET_NOTIF_MENTION, true);
                notif_share = sharedpreferences.getBoolean(Helper.SET_NOTIF_SHARE, true);
                notif_poll = sharedpreferences.getBoolean(Helper.SET_NOTIF_POLL, true);
                notif_status = sharedpreferences.getBoolean(Helper.SET_NOTIF_STATUS, true);
            }


            if (!notif_follow) {
                parameters.append("exclude_types[]=").append("follow").append("&");
                parameters.append("exclude_types[]=").append("follow_request").append("&");
            }
            if (!notif_add)
                parameters.append("exclude_types[]=").append("favourite").append("&");
            if (!notif_share)
                parameters.append("exclude_types[]=").append("reblog").append("&");
            if (!notif_status)
                parameters.append("exclude_types[]=").append("status").append("&");
            if (!notif_mention)
                parameters.append("exclude_types[]=").append("mention").append("&");
            if (!notif_poll)
                parameters.append("exclude_types[]=").append("poll").append("&");
            if (parameters.length() > 0) {
                parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
                params.put("exclude_types[]", parameters.toString());
            }
        } else if (type == DisplayNotificationsFragment.Type.MENTION) {
            parameters.append("exclude_types[]=").append("follow").append("&");
            parameters.append("exclude_types[]=").append("follow_request").append("&");
            parameters.append("exclude_types[]=").append("favourite").append("&");
            parameters.append("exclude_types[]=").append("reblog").append("&");
            parameters.append("exclude_types[]=").append("status").append("&");
            parameters.append("exclude_types[]=").append("poll").append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
            params.put("exclude_types[]", parameters.toString());
        } else if (type == DisplayNotificationsFragment.Type.FAVORITE) {
            parameters.append("exclude_types[]=").append("follow").append("&");
            parameters.append("exclude_types[]=").append("follow_request").append("&");
            parameters.append("exclude_types[]=").append("mention").append("&");
            parameters.append("exclude_types[]=").append("status").append("&");
            parameters.append("exclude_types[]=").append("reblog").append("&");
            parameters.append("exclude_types[]=").append("poll").append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
            params.put("exclude_types[]", parameters.toString());
        } else if (type == DisplayNotificationsFragment.Type.BOOST) {
            parameters.append("exclude_types[]=").append("follow").append("&");
            parameters.append("exclude_types[]=").append("follow_request").append("&");
            parameters.append("exclude_types[]=").append("status").append("&");
            parameters.append("exclude_types[]=").append("mention").append("&");
            parameters.append("exclude_types[]=").append("favourite").append("&");
            parameters.append("exclude_types[]=").append("poll").append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
            params.put("exclude_types[]", parameters.toString());
        } else if (type == DisplayNotificationsFragment.Type.POLL) {
            parameters.append("exclude_types[]=").append("reblog").append("&");
            parameters.append("exclude_types[]=").append("follow").append("&");
            parameters.append("exclude_types[]=").append("status").append("&");
            parameters.append("exclude_types[]=").append("follow_request").append("&");
            parameters.append("exclude_types[]=").append("mention").append("&");
            parameters.append("exclude_types[]=").append("favourite").append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
            params.put("exclude_types[]", parameters.toString());
        } else if (type == DisplayNotificationsFragment.Type.FOLLOW) {
            parameters.append("exclude_types[]=").append("status").append("&");
            parameters.append("exclude_types[]=").append("reblog").append("&");
            parameters.append("exclude_types[]=").append("mention").append("&");
            parameters.append("exclude_types[]=").append("favourite").append("&");
            parameters.append("exclude_types[]=").append("poll").append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
            params.put("exclude_types[]", parameters.toString());
        } else if (type == DisplayNotificationsFragment.Type.STATUS) {
            parameters.append("exclude_types[]=").append("follow").append("&");
            parameters.append("exclude_types[]=").append("reblog").append("&");
            parameters.append("exclude_types[]=").append("mention").append("&");
            parameters.append("exclude_types[]=").append("favourite").append("&");
            parameters.append("exclude_types[]=").append("poll").append("&");
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(16));
            params.put("exclude_types[]", parameters.toString());
        }

        List<Notification> notifications = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/notifications"), 10, params, prefKeyOauthTokenT);
            notifications = parseNotificationResponse(new JSONArray(response));
            setNotificationsMaxId(httpsConnection, notifications);
        } catch (HttpsConnection.HttpsConnectionException e) {
            e.printStackTrace();
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        if (apiResponse != null) {
            apiResponse.setNotifications(notifications);
        }
        return apiResponse;
    }

    /**
     * Changes media description
     *
     * @param mediaId     String
     * @param description String
     * @return Attachment
     */
    public Attachment updateDescription(String mediaId, String description) {

        HashMap<String, String> params = new HashMap<>();
        try {
            params.put("description", URLEncoder.encode(description, "UTF-8"));
        } catch (UnsupportedEncodingException e) {
            params.put("description", description);
        }
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.put(getAbsoluteUrl(String.format("/media/%s", mediaId)), 240, params, prefKeyOauthTokenT);
            attachment = parseAttachmentResponse(new JSONObject(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return attachment;
    }

    /**
     * Retrieves Accounts and feeds when searching *synchronously*
     *
     * @param query String search
     * @return Results
     */
    public APIResponse search(String query) {

        HashMap<String, String> params = new HashMap<>();
        apiResponse = new APIResponse();
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PEERTUBE)
            params.put("q", query);
        else
            try {
                params.put("q", URLEncoder.encode(query, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                params.put("q", query);
            }
        params.put("resolve", "true");
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUr2l("/search"), 10, params, prefKeyOauthTokenT);
            results = parseResultsResponse(new JSONObject(response));
            apiResponse.setResults(results);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Retrieves trends for Mastodon *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getTrends() {

        List<Trends> trends;
        apiResponse = new APIResponse();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/trends"), 10, null, null);
            trends = parseTrends(new JSONArray(response));
            apiResponse.setTrends(trends);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Retrieves Accounts and feeds when searching *synchronously*
     *
     * @param query String search
     * @return Results
     */
    public APIResponse search2(String query, searchType type, String offset) {
        apiResponse = new APIResponse();
        HashMap<String, String> params = new HashMap<>();
        if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PEERTUBE)
            params.put("q", query);
        else
            try {
                params.put("q", URLEncoder.encode(query, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                params.put("q", query);
            }
        if (offset != null)
            params.put("offset", offset);
        if (type != null) {
            switch (type) {
                case TAGS:
                    params.put("type", "hashtags");
                    break;
                case ACCOUNTS:
                    params.put("type", "accounts");
                    break;
                case STATUSES:
                    params.put("type", "statuses");
                    break;
            }
        }
        params.put("limit", "20");
        params.put("resolve", "true");
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response;
            if (MainActivity.social != UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                response = httpsConnection.get(getAbsoluteUr2l("/search"), 10, params, prefKeyOauthTokenT);
            } else {
                String searchPixelfed;
                try {
                    searchPixelfed = "q=" + URLEncoder.encode(query, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    searchPixelfed = "q=" + query;
                }
                response = httpsConnection.get(Helper.getLiveInstanceWithProtocol(context) + "/api/search?" + searchPixelfed + "&src=metro&v=2&scope=all", 10, null, prefKeyOauthTokenT);
            }
            results = parseResultsResponse(new JSONObject(response));
            apiResponse.setSince_id(httpsConnection.getSince_id());
            apiResponse.setMax_id(httpsConnection.getMax_id());
            apiResponse.setResults(results);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Retrieves Accounts when searching (ie: via @...) *synchronously*
     * Not limited to following
     *
     * @param query String search
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse searchAccounts(String query, int count) {
        return searchAccounts(query, count, false);
    }

    /**
     * Retrieves Accounts when searching (ie: via @...) *synchronously*
     *
     * @param query     String search
     * @param count     int limit
     * @param following boolean following only
     * @return APIResponse
     */
    public APIResponse searchAccounts(String query, int count, boolean following) {

        HashMap<String, String> params = new HashMap<>();
        params.put("q", query);
        if (count < 5)
            count = 5;
        if (count > 40)
            count = 40;
        if (following)
            params.put("following", Boolean.toString(true));
        params.put("limit", String.valueOf(count));

        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/accounts/search"), 10, params, prefKeyOauthTokenT);
            accounts = parseAccountResponse(new JSONArray(response));
            setAccountsMaxId(httpsConnection, accounts);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Retrieves Accounts when searching (ie: via @...) *synchronously*
     *
     * @return APIResponse
     */
    public APIResponse getCustomEmoji() {
        List<Emojis> emojis = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl("/custom_emojis"), 30, null, prefKeyOauthTokenT);
            emojis = parseEmojis(new JSONArray(response));

        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        //Add custom emoji for Pleroma
        /*if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PLEROMA) {
            APIResponse apiResponsePleroma = getCustomPleromaEmoji();
            if (apiResponsePleroma != null && apiResponsePleroma.getEmojis() != null && apiResponsePleroma.getEmojis().size() > 0)
                emojis.addAll(apiResponsePleroma.getEmojis());
        }*/
        apiResponse.setEmojis(emojis);
        return apiResponse;
    }

    /**
     * Check if it's a Pleroma admin account and change in settings *synchronously*
     */
    private void isPleromaAdmin(String nickname) {
        SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        boolean isAdmin;
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            httpsConnection.get(String.format(Helper.getLiveInstanceWithProtocol(context) + "/api/pleroma/admin/permission_group/%s/admin", nickname), 10, null, prefKeyOauthTokenT);
            //Call didn't return a 404, so the account is admin
            isAdmin = true;
        } catch (Exception e) {
            isAdmin = false;
        }
        SharedPreferences.Editor editor = sharedpreferences.edit();
        editor.putBoolean(Helper.PREF_IS_ADMINISTRATOR, isAdmin);
        editor.apply();
    }

    /**
     * Get filters for the user
     *
     * @return APIResponse
     */
    public APIResponse getFilters() {

        List<Filters> filters = null;
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/filters"), 10, null, prefKeyOauthTokenT);
            if (response == null) {
                apiResponse.setFilters(new ArrayList<>());
                return apiResponse;
            }
            filters = parseFilters(new JSONArray(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setFilters(filters);
        return apiResponse;
    }

    /**
     * Get a Filter by its id
     *
     * @return APIResponse
     */
    public APIResponse getFilters(String filterId) {

        List<Filters> filters = new ArrayList<>();
        Filters filter;
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl(String.format("/filters/%s", filterId)), 10, null, prefKeyOauthTokenT);
            filter = parseFilter(new JSONObject(response));
            filters.add(filter);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setFilters(filters);
        return apiResponse;
    }

    /**
     * Create a filter
     *
     * @param filter Filter
     * @return APIResponse
     */
    public APIResponse addFilters(Filters filter) {
        HashMap<String, String> params = new HashMap<>();
        params.put("phrase", filter.getPhrase());
        StringBuilder parameters = new StringBuilder();
        for (String context : filter.getContext())
            parameters.append("context[]=").append(context).append("&");
        if (parameters.length() > 0) {
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(10));
            params.put("context[]", parameters.toString());
        }
        params.put("irreversible", String.valueOf(filter.isIrreversible()));
        params.put("whole_word", String.valueOf(filter.isWhole_word()));
        params.put("expires_in", String.valueOf(filter.getExpires_in()));
        ArrayList<Filters> filters = new ArrayList<>();
        try {
            String response = new HttpsConnection(context, this.instance).post(getAbsoluteUrl("/filters"), 10, params, prefKeyOauthTokenT);
            Filters resfilter = parseFilter(new JSONObject(response));
            filters.add(resfilter);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setFilters(filters);
        return apiResponse;
    }

    /**
     * Delete a filter
     *
     * @param filter Filter
     * @return APIResponse
     */
    public int deleteFilters(Filters filter) {

        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            httpsConnection.delete(getAbsoluteUrl(String.format("/filters/%s", filter.getId())), 10, null, prefKeyOauthTokenT);
            actionCode = httpsConnection.getActionCode();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return actionCode;
    }

    /**
     * Delete a filter
     *
     * @param filter Filter
     * @return APIResponse
     */
    public APIResponse updateFilters(Filters filter) {
        HashMap<String, String> params = new HashMap<>();
        params.put("phrase", filter.getPhrase());
        StringBuilder parameters = new StringBuilder();
        for (String context : filter.getContext())
            parameters.append("context[]=").append(context).append("&");
        if (parameters.length() > 0) {
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(10));
            params.put("context[]", parameters.toString());
        }
        params.put("irreversible", String.valueOf(filter.isIrreversible()));
        params.put("whole_word", String.valueOf(filter.isWhole_word()));
        params.put("expires_in", String.valueOf(filter.getExpires_in()));
        ArrayList<Filters> filters = new ArrayList<>();
        try {
            String response = new HttpsConnection(context, this.instance).put(getAbsoluteUrl(String.format("/filters/%s", filter.getId())), 10, params, prefKeyOauthTokenT);
            Filters resfilter = parseFilter(new JSONObject(response));
            filters.add(resfilter);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setFilters(filters);
        return apiResponse;
    }

    /**
     * Get lists for the user
     *
     * @return APIResponse
     */
    public APIResponse getLists() {
        apiResponse = new APIResponse();
        List<app.fedilab.android.client.Entities.List> lists = new ArrayList<>();
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/lists"), 5, null, prefKeyOauthTokenT);
            lists = parseLists(new JSONArray(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setLists(lists);
        return apiResponse;
    }

    /**
     * Retrieves list timeline  *synchronously*
     *
     * @param list_id  String id of the list
     * @param max_id   String id max
     * @param since_id String since the id
     * @param limit    int limit  - max value 40
     * @return APIResponse
     */
    public APIResponse getListTimeline(String list_id, String max_id, String since_id, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (max_id != null)
            params.put("max_id", max_id);
        if (since_id != null)
            params.put("since_id", since_id);
        if (0 > limit || limit > 80)
            limit = 80;
        params.put("limit", String.valueOf(limit));
        statuses = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/timelines/list/%s", list_id)), 10, params, prefKeyOauthTokenT);
            statuses = parseStatuses(context, new JSONArray(response));
            setStatusesMaxId(httpsConnection, statuses);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return apiResponse;
    }

    /**
     * Get accounts in a list for a user
     *
     * @param listId String, id of the list
     * @param limit  int, limit of results
     * @return APIResponse
     */
    @SuppressWarnings("SameParameterValue")
    public APIResponse getAccountsInList(String listId, int limit) {

        HashMap<String, String> params = new HashMap<>();
        if (limit < 0)
            limit = 0;
        if (limit > 50)
            limit = 50;
        params.put("limit", String.valueOf(limit));
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrl(String.format("/lists/%s/accounts", listId)), 10, params, prefKeyOauthTokenT);
            accounts = parseAccountResponse(new JSONArray(response));
            setAccountsMaxId(httpsConnection, accounts);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setAccounts(accounts);
        return apiResponse;
    }

    /**
     * Add an account in a list
     *
     * @param id          String, id of the list
     * @param account_ids String, account to add
     * @return APIResponse
     */
    public APIResponse addAccountToList(String id, String[] account_ids) {

        HashMap<String, String> params = new HashMap<>();
        StringBuilder parameters = new StringBuilder();
        for (String val : account_ids)
            parameters.append("account_ids[]=").append(val).append("&");
        if (parameters.length() > 0) {
            parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(14));
            params.put("account_ids[]", parameters.toString());
        }
        try {
            new HttpsConnection(context, this.instance).post(getAbsoluteUrl(String.format("/lists/%s/accounts", id)), 10, params, prefKeyOauthTokenT);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException e) {
            e.printStackTrace();
        }
        return apiResponse;
    }

    /**
     * Delete an account from a list
     *
     * @param id String, the id of the list
     * @return APIResponse
     */
    public int deleteAccountFromList(String id, String[] account_ids) {
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            StringBuilder parameters = new StringBuilder();
            HashMap<String, String> params = new HashMap<>();
            for (String val : account_ids)
                parameters.append("account_ids[]=").append(val).append("&");
            if (parameters.length() > 0) {
                parameters = new StringBuilder(parameters.substring(0, parameters.length() - 1).substring(14));
                params.put("account_ids[]", parameters.toString());
            }
            httpsConnection.delete(getAbsoluteUrl(String.format("/lists/%s/accounts", id)), 10, params, prefKeyOauthTokenT);
            actionCode = httpsConnection.getActionCode();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | KeyManagementException | IOException e) {
            e.printStackTrace();
        }
        return actionCode;
    }

    /**
     * Posts a list
     *
     * @param title String, the title of the list
     * @return APIResponse
     */
    public APIResponse createList(String title) {

        HashMap<String, String> params = new HashMap<>();
        params.put("title", title);
        List<app.fedilab.android.client.Entities.List> lists = new ArrayList<>();
        app.fedilab.android.client.Entities.List list;
        try {
            String response = new HttpsConnection(context, this.instance).post(getAbsoluteUrl("/lists"), 10, params, prefKeyOauthTokenT);
            list = parseList(new JSONObject(response));
            lists.add(list);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setLists(lists);
        return apiResponse;
    }

    /**
     * Get subscribed push notifications
     *
     * @return APIResponse
     */
    public APIResponse getPushSubscription() {
        PushSubscription pushSubscription = null;
        try {
            String response = new HttpsConnection(context, this.instance).get(getAbsoluteUrl("/push/subscription"), 10, null, prefKeyOauthTokenT);
            pushSubscription = parsePushNotifications(new JSONObject(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setPushSubscription(pushSubscription);
        return apiResponse;
    }


    /**
     * Update subscribed push notifications
     *
     * @return APIResponse
     */
    public APIResponse updatePushSubscription(String endpoint) {
        PushSubscription pushSubscription = new PushSubscription();
        final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        boolean notif_follow = sharedpreferences.getBoolean(Helper.SET_NOTIF_FOLLOW, true);
        boolean notif_add = sharedpreferences.getBoolean(Helper.SET_NOTIF_ADD, true);
        boolean notif_mention = sharedpreferences.getBoolean(Helper.SET_NOTIF_MENTION, true);
        boolean notif_share = sharedpreferences.getBoolean(Helper.SET_NOTIF_SHARE, true);
        boolean notif_status = sharedpreferences.getBoolean(Helper.SET_NOTIF_STATUS, true);
        boolean notif_poll = sharedpreferences.getBoolean(Helper.SET_NOTIF_POLL, true);


        HashMap<String, String> params = new HashMap<>();
        try {
            endpoint = URLEncoder.encode(endpoint, "UTF-8");
        } catch (UnsupportedEncodingException ignored) {
        }
        params.put("subscription[endpoint]", endpoint);
        params.put("data[alerts][follow]", String.valueOf(notif_follow));
        params.put("data[alerts][mention]", String.valueOf(notif_mention));
        params.put("data[alerts][favourite]", String.valueOf(notif_add));
        params.put("data[alerts][reblog]", String.valueOf(notif_share));
        params.put("data[alerts][poll]", String.valueOf(notif_poll));

        try {

            String response = new HttpsConnection(context, this.instance).put(getAbsoluteUrl("/push/subscription"), 10, params, prefKeyOauthTokenT);
            pushSubscription = parsePushNotifications(new JSONObject(response));
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setPushSubscription(pushSubscription);
        return apiResponse;
    }

    /**
     * Subscribe to push notifications
     *
     * @return APIResponse
     */
    public APIResponse pushSubscription(String endpoint, Account account) {
        PushSubscription pushSubscription = new PushSubscription();
        final SharedPreferences sharedpreferences = context.getSharedPreferences(Helper.APP_PREFS, Context.MODE_PRIVATE);
        boolean notif_follow = sharedpreferences.getBoolean(Helper.SET_NOTIF_FOLLOW, true);
        boolean notif_add = sharedpreferences.getBoolean(Helper.SET_NOTIF_ADD, true);
        boolean notif_mention = sharedpreferences.getBoolean(Helper.SET_NOTIF_MENTION, true);
        boolean notif_share = sharedpreferences.getBoolean(Helper.SET_NOTIF_SHARE, true);
        boolean notif_status = sharedpreferences.getBoolean(Helper.SET_NOTIF_STATUS, true);
        boolean notif_poll = sharedpreferences.getBoolean(Helper.SET_NOTIF_POLL, true);

        SharedPreferences prefs = PreferenceManager
                .getDefaultSharedPreferences(context);
        String strPub = prefs.getString(kp_public, "");
        String strPriv = prefs.getString(kp_private, "");
        if (strPub.trim().isEmpty() || strPriv.trim().isEmpty()) {
            newPair(context);
        }

        ECDH ecdh = ECDH.getInstance();
        String pubKey = ecdh.getPublicKey(context);
        byte[] randBytes = new byte[16];
        new Random().nextBytes(randBytes);
        String auth = ECDH.base64Encode(randBytes);
        JSONObject jsonObject = new JSONObject();

        try {
            JSONObject jsonObjectSub = new JSONObject();
            jsonObjectSub.put("endpoint", endpoint);
            JSONObject jsonObjectkey = new JSONObject();
            jsonObjectkey.put("p256dh", pubKey);
            jsonObjectkey.put("auth", auth);
            jsonObjectSub.put("keys", jsonObjectkey);
            jsonObject.put("subscription", jsonObjectSub);

            JSONObject jsonObjectdata = new JSONObject();
            JSONObject jsonObjectarlerts = new JSONObject();
            jsonObjectarlerts.put("follow", notif_follow);
            jsonObjectarlerts.put("mention", notif_mention);
            jsonObjectarlerts.put("favourite", notif_add);
            jsonObjectarlerts.put("reblog", notif_share);
            jsonObjectarlerts.put("poll", notif_poll);
            jsonObjectdata.put("alerts", jsonObjectarlerts);
            jsonObject.put("data", jsonObjectdata);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        try {
            String response = new HttpsConnection(context, this.instance).postJson(getAbsoluteUrl("/push/subscription"), 10, jsonObject, prefKeyOauthTokenT);
            pushSubscription = parsePushNotifications(new JSONObject(response));
            ecdh.saveServerKey(context, account, pushSubscription.getServer_key());
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
            e.printStackTrace();
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setPushSubscription(pushSubscription);
        return apiResponse;
    }

    /**
     * Update a list by its id
     *
     * @param id    String, the id of the list
     * @param title String, the title of the list
     * @return APIResponse
     */
    public APIResponse updateList(String id, String title) {

        HashMap<String, String> params = new HashMap<>();
        params.put("title", title);
        List<app.fedilab.android.client.Entities.List> lists = new ArrayList<>();
        app.fedilab.android.client.Entities.List list;
        try {
            String response = new HttpsConnection(context, this.instance).put(getAbsoluteUrl(String.format("/lists/%s", id)), 10, params, prefKeyOauthTokenT);
            list = parseList(new JSONObject(response));
            lists.add(list);
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setLists(lists);
        return apiResponse;
    }

    /**
     * Delete a list by its id
     *
     * @param id String, the id of the list
     * @return APIResponse
     */
    public int deleteList(String id) {
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            httpsConnection.delete(getAbsoluteUrl(String.format("/lists/%s", id)), 10, null, prefKeyOauthTokenT);
            actionCode = httpsConnection.getActionCode();
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (Exception e) {
            setDefaultError(e);
        }
        return actionCode;
    }

    /**
     * Retrieves list from Communitywiki *synchronously*
     *
     * @return APIResponse
     */
    public ArrayList<String> getCommunitywikiList() {
        ArrayList<String> list = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrlCommunitywiki("/list"), 10, null, prefKeyOauthTokenT);

            JSONArray jsonArray = new JSONArray(response);
            int len = jsonArray.length();
            for (int i = 0; i < len; i++) {
                list.add(jsonArray.get(i).toString());
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return list;
    }

    /**
     * Retrieves list from Communitywiki *synchronously*
     *
     * @return APIResponse
     */
    public ArrayList<String> getCommunitywikiList(String name) {
        ArrayList<String> list = new ArrayList<>();
        try {
            HttpsConnection httpsConnection = new HttpsConnection(context, this.instance);
            String response = httpsConnection.get(getAbsoluteUrlCommunitywiki(String.format("/list/%s", name)), 10, null, prefKeyOauthTokenT);

            JSONArray jsonArray = new JSONArray(response);
            for (int i = 0; i < jsonArray.length(); i++) {
                try {
                    list.add(jsonArray.getJSONObject(i).getString("acct"));
                } catch (JSONException ignored) {
                }
            }
        } catch (HttpsConnection.HttpsConnectionException e) {
            setError(e.getStatusCode(), e);
        } catch (NoSuchAlgorithmException | IOException | KeyManagementException | JSONException e) {
            e.printStackTrace();
        }
        apiResponse.setStatuses(statuses);
        return list;
    }

    /**
     * Parse json response an unique account
     *
     * @param resobj JSONObject
     * @return Account
     */
    private Results parseResultsResponse(JSONObject resobj) {

        Results results = new Results();
        try {
            if (resobj.has("accounts")) {
                results.setAccounts(parseAccountResponse(resobj.getJSONArray("accounts")));
            }
            if (resobj.has("profiles")) {
                results.setAccounts(parseAccountPixelfedSearchResponse(resobj.getJSONArray("profiles")));
            }
            if (resobj.has("statuses")) {
                results.setStatuses(parseStatuses(context, resobj.getJSONArray("statuses")));
            }
            results.setTrends(parseTrends(resobj.getJSONArray("hashtags")));
            results.setHashtags(parseTags(resobj.getJSONArray("hashtags")));
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return results;
    }

    /**
     * Parse Domains
     *
     * @param jsonArray JSONArray
     * @return List<String> of domains
     */
    private List<String> parseDomains(JSONArray jsonArray) {
        List<String> list_tmp = new ArrayList<>();
        for (int i = 0; i < jsonArray.length(); i++) {
            try {
                list_tmp.add(jsonArray.getString(i));
            } catch (JSONException ignored) {
            }
        }
        return list_tmp;
    }

    /**
     * Parse Tags
     *
     * @param jsonArray JSONArray
     * @return List<String> of tags
     */
    private List<String> parseTags(JSONArray jsonArray) {
        List<String> list_tmp = new ArrayList<>();
        for (int i = 0; i < jsonArray.length(); i++) {

            try {
                if (jsonArray.get(i) instanceof JSONObject) {
                    if (jsonArray.getJSONObject(i).has("name")) {
                        list_tmp.add(jsonArray.getJSONObject(i).getString("name"));
                    } else if (jsonArray.getJSONObject(i).has("value")) {
                        list_tmp.add(jsonArray.getJSONObject(i).getString("value"));
                    }
                } else {
                    list_tmp.add(jsonArray.getString(i));
                }
            } catch (JSONException ignored) {
            }
        }
        return list_tmp;
    }

    /**
     * Parse json response for several howto
     *
     * @param jsonArray JSONArray
     * @return List<HowToVideo>
     */
    private List<HowToVideo> parseHowTos(JSONArray jsonArray) {

        List<HowToVideo> howToVideos = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                HowToVideo howToVideo = parseHowTo(resobj);
                i++;
                howToVideos.add(howToVideo);
            }

        } catch (JSONException e) {
            setDefaultError(e);
        }
        return howToVideos;
    }

    /**
     * Parse json response for several howto
     *
     * @param jsonArray JSONArray
     * @return List<Peertube>
     */
    private List<Peertube> parsePeertube(String instance, JSONArray jsonArray) {

        List<Peertube> peertubes = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Peertube peertube = parsePeertube(instance, resobj);
                i++;
                peertubes.add(peertube);
            }

        } catch (JSONException e) {
            setDefaultError(e);
        }
        return peertubes;
    }

    /**
     * Parse json response for several trends
     *
     * @param jsonArray JSONArray
     * @return List<Trends>
     */
    private List<Trends> parseTrends(JSONArray jsonArray) {

        List<Trends> trends = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Trends trend = parseTrends(resobj);
                i++;
                trends.add(trend);
            }

        } catch (JSONException e) {
            setDefaultError(e);
        }
        return trends;
    }

    /**
     * Parse json response for unique trend
     *
     * @param resobj JSONObject
     * @return Trend
     */
    private Trends parseTrends(JSONObject resobj) {
        Trends trend = new Trends();
        try {
            if (resobj.has("name") && !resobj.isNull("name")) {
                trend.setName(resobj.getString("name"));
            } else if (resobj.has("value")) {
                trend.setName(resobj.getString("value"));
            }
            trend.setUrl(resobj.getString("url"));
            List<TrendsHistory> historyList = new ArrayList<>();
            if (resobj.has("history")) {
                JSONArray histories = resobj.getJSONArray("history");
                for (int i = 0; i < histories.length(); i++) {
                    JSONObject hystory = histories.getJSONObject(i);
                    TrendsHistory trendsHistory = new TrendsHistory();
                    trendsHistory.setDays(hystory.getLong("day"));
                    trendsHistory.setUses(hystory.getInt("uses"));
                    trendsHistory.setAccounts(hystory.getInt("accounts"));
                    historyList.add(trendsHistory);
                }
            }
            trend.setTrendsHistory(historyList);
        } catch (JSONException ignored) {
        }
        return trend;
    }

    /**
     * Parse json response for several conversations
     *
     * @param jsonArray JSONArray
     * @return List<Conversation>
     */
    private List<Conversation> parseConversations(JSONArray jsonArray) {

        List<Conversation> conversations = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Conversation conversation = parseConversation(context, resobj);
                i++;
                conversations.add(conversation);
            }

        } catch (JSONException e) {
            setDefaultError(e);
        }
        return conversations;
    }

    /**
     * Parse json response for unique conversation
     *
     * @param resobj JSONObject
     * @return Conversation
     */
    private Conversation parseConversation(Context context, JSONObject resobj) {
        Conversation conversation = new Conversation();
        try {
            conversation.setId(resobj.getString("id"));
            conversation.setUnread(resobj.getBoolean("unread"));
            conversation.setAccounts(parseAccountResponse(resobj.getJSONArray("accounts")));
            conversation.setLast_status(parseStatuses(context, resobj.getJSONObject("last_status")));
        } catch (JSONException ignored) {
        }
        return conversation;
    }

    /**
     * Parse json response for several status
     *
     * @param jsonArray JSONArray
     * @return List<Status>
     */
    private List<Status> parseStatusesForCache(Context context, JSONArray jsonArray) {
        SQLiteDatabase db = Sqlite.getInstance(context.getApplicationContext(), Sqlite.DB_NAME, null, Sqlite.DB_VERSION).open();
        Account account = new AccountDAO(context, db).getAccountByToken(prefKeyOauthTokenT);
        List<Status> statuses = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Status status = parseStatuses(context, resobj);
                Status alreadyCached = new TimelineCacheDAO(context, db).getSingle(status.getId());
                if (alreadyCached == null && account != null && account.getId() != null && account.getInstance() != null) {
                    new TimelineCacheDAO(context, db).insert(status.getId(), resobj.toString(), account.getId(), account.getInstance());
                }
                i++;
                statuses.add(status);
            }

        } catch (JSONException e) {
            e.printStackTrace();
        }
        return statuses;
    }

    /**
     * Parse json response an unique instance
     *
     * @param resobj JSONObject
     * @return Instance
     */
    private Instance parseInstance(JSONObject resobj) {

        Instance instance = new Instance();
        try {
            instance.setUri(resobj.getString("uri"));
            instance.setTitle(resobj.getString("title"));
            instance.setDescription(resobj.getString("description"));
            instance.setEmail(resobj.getString("email"));
            instance.setVersion(resobj.getString("version"));
            if (resobj.has("registrations")) {
                instance.setRegistration(resobj.getBoolean("registrations"));
            } else {
                instance.setRegistration(false);
            }
            if (resobj.has("approval_required")) {
                instance.setApproval_required(resobj.getBoolean("approval_required"));
            } else {
                instance.setApproval_required(false);
            }
            if (resobj.has("poll_limits")) {
                HashMap<String, Integer> poll_limits = new HashMap<>();
                JSONObject polllimits = resobj.getJSONObject("poll_limits");
                poll_limits.put("min_expiration", polllimits.getInt("min_expiration"));
                poll_limits.put("max_options", polllimits.getInt("max_options"));
                poll_limits.put("max_option_chars", polllimits.getInt("max_option_chars"));
                poll_limits.put("max_expiration", polllimits.getInt("max_expiration"));
                instance.setPoll_limits(poll_limits);
            }
            if (resobj.has("thumbnail")) {
                instance.setThumbnail(resobj.getString("thumbnail"));
            }
            if (resobj.has("stats")) {
                JSONObject stats = resobj.getJSONObject("stats");
                if (stats.has("user_count")) {
                    instance.setUserCount(stats.getInt("user_count"));
                }
                if (stats.has("status_count")) {
                    instance.setStatusCount(stats.getInt("status_count"));
                }
                if (stats.has("domain_count")) {
                    instance.setDomainCount(stats.getInt("domain_count"));
                }
            }
            if (resobj.has("contact_account")) {
                instance.setContactAccount(parseAccountResponse(resobj.getJSONObject("contact_account")));
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return instance;
    }

    /**
     * Parse json response for several instance reg
     *
     * @param jsonArray JSONArray
     * @return List<Status>
     */
    private List<InstanceReg> parseInstanceReg(JSONArray jsonArray) {

        List<InstanceReg> instanceRegs = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                InstanceReg instanceReg = parseInstanceReg(resobj);
                i++;
                instanceRegs.add(instanceReg);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return instanceRegs;
    }

    /**
     * Parse json response an unique instance for registering
     *
     * @param resobj JSONObject
     * @return InstanceReg
     */
    private InstanceReg parseInstanceReg(JSONObject resobj) {
        InstanceReg instanceReg = new InstanceReg();
        try {
            instanceReg.setDomain(resobj.getString("domain"));
            instanceReg.setVersion(resobj.getString("version"));
            instanceReg.setDescription(resobj.getString("description"));
            instanceReg.setLanguage(resobj.getString("language"));
            instanceReg.setCategory(resobj.getString("category"));
            instanceReg.setProxied_thumbnail(resobj.getString("proxied_thumbnail"));
            instanceReg.setTotal_users(resobj.getInt("total_users"));
            instanceReg.setLast_week_users(resobj.getInt("last_week_users"));
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return instanceReg;
    }

    /**
     * Parse emojis
     *
     * @param jsonArray JSONArray
     * @return List<Emojis> of emojis
     */
    private List<Emojis> parseEmojis(JSONArray jsonArray) {
        List<Emojis> emojis = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Emojis emojis1 = parseEmojis(resobj);
                if (emojis1.isVisible_in_picker())
                    emojis.add(emojis1);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return emojis;
    }

    /**
     * Parse Filters
     *
     * @param jsonArray JSONArray
     * @return List<Filters> of filters
     */
    private List<Filters> parseFilters(JSONArray jsonArray) {
        List<Filters> filters = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Filters filter = parseFilter(resobj);
                if (filter != null)
                    filters.add(filter);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return filters;
    }

    /**
     * Parse json response for filter
     *
     * @param resobj JSONObject
     * @return Filter
     */
    private Filters parseFilter(JSONObject resobj) {
        Filters filter = new Filters();
        try {

            filter.setId(resobj.getString("id"));
            filter.setPhrase(resobj.getString("phrase"));
            resobj.get("expires_at");
            if (!resobj.getString("expires_at").equals("null"))
                filter.setSetExpires_at(Helper.mstStringToDate(resobj.getString("expires_at")));
            filter.setWhole_word(resobj.getBoolean("whole_word"));
            filter.setIrreversible(resobj.getBoolean("irreversible"));
            String contextString = resobj.getString("context");
            contextString = contextString.replaceAll("\\[", "");
            contextString = contextString.replaceAll("]", "");
            contextString = contextString.replaceAll("\"", "");
            String[] context = contextString.split(",");
            if (contextString.length() > 0) {
                ArrayList<String> finalContext = new ArrayList<>();
                for (String c : context)
                    finalContext.add(c.trim());
                filter.setContext(finalContext);
            }
            return filter;
        } catch (Exception ignored) {
            return null;
        }

    }

    /**
     * Parse Lists
     *
     * @param jsonArray JSONArray
     * @return List<List> of lists
     */
    private List<app.fedilab.android.client.Entities.List> parseLists(JSONArray jsonArray) {
        List<app.fedilab.android.client.Entities.List> lists = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                app.fedilab.android.client.Entities.List list = parseList(resobj);
                lists.add(list);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return lists;
    }

    private List<Account> parseAccountResponsePeertube(String instance, JSONArray jsonArray) {
        List<Account> accounts = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Account account = parseAccountResponsePeertube(instance, resobj);
                accounts.add(account);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return accounts;
    }

    /**
     * Parse json response for list of reports for admins
     *
     * @param jsonArray JSONArray
     * @return List<Report>
     */
    private List<Report> parseReportAdminResponse(JSONArray jsonArray) {

        List<Report> reports = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Report report = parseReportAdminResponse(context, resobj);
                reports.add(report);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return reports;
    }

    /**
     * Parse json response for list of accounts for admins
     *
     * @param jsonArray JSONArray
     * @return List<AccountAdmin>
     */
    private List<AccountAdmin> parseAccountAdminResponse(JSONArray jsonArray) {

        List<AccountAdmin> accountAdmins = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                AccountAdmin accountAdmin = parseAccountAdminResponse(resobj);
                accountAdmins.add(accountAdmin);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return accountAdmins;
    }

    /**
     * Parse json response for list of accounts
     *
     * @param jsonArray JSONArray
     * @return List<Account>
     */
    private List<Account> parseAccountResponse(JSONArray jsonArray) {

        List<Account> accounts = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Account account = parseAccountResponse(resobj);
                accounts.add(account);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return accounts;
    }


    /**
     * Parse json response for list of accounts
     *
     * @param jsonArray JSONArray
     * @return List<Account>
     */
    private List<Account> parseAccountPixelfedSearchResponse(JSONArray jsonArray) {

        List<Account> accounts = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Account account = parseAccountPixelfedSearchResponse(resobj);
                accounts.add(account);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return accounts;
    }

    /**
     * Parse json response an unique relationship
     *
     * @param resobj JSONObject
     * @return Relationship
     */
    private Relationship parseRelationshipResponse(JSONObject resobj) {

        Relationship relationship = new Relationship();
        try {
            relationship.setId(resobj.getString("id"));
            relationship.setFollowing(resobj.getBoolean("following"));
            relationship.setFollowed_by(resobj.getBoolean("followed_by"));
            relationship.setBlocking(resobj.getBoolean("blocking"));
            relationship.setMuting(resobj.getBoolean("muting"));
            try {
                relationship.setMuting_notifications(resobj.getBoolean("muting_notifications"));
            } catch (Exception ignored) {
                relationship.setMuting_notifications(true);
            }
            try {
                relationship.setEndorsed(resobj.getBoolean("endorsed"));
            } catch (Exception ignored) {
                relationship.setMuting_notifications(false);
            }
            try {
                relationship.setShowing_reblogs(resobj.getBoolean("showing_reblogs"));
            } catch (Exception ignored) {
                relationship.setMuting_notifications(false);
            }
            try {
                relationship.setBlocked_by(resobj.getBoolean("blocked_by"));
            } catch (Exception ignored) {
                relationship.setBlocked_by(false);
            }
            try {
                relationship.setDomain_blocking(resobj.getBoolean("domain_blocking"));
            } catch (Exception ignored) {
                relationship.setDomain_blocking(false);
            }
            if (resobj.has("note")) {
                relationship.setNote(resobj.getString("note"));
            }
            try {
                relationship.setNotifying(resobj.getBoolean("notifying"));
            } catch (Exception ignored) {
                relationship.setNotifying(false);
            }
            relationship.setRequested(resobj.getBoolean("requested"));
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return relationship;
    }

    /**
     * Parse json response for list of relationship
     *
     * @param jsonArray JSONArray
     * @return List<Relationship>
     */
    private List<Relationship> parseRelationshipResponse(JSONArray jsonArray) {

        List<Relationship> relationships = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {
                JSONObject resobj = jsonArray.getJSONObject(i);
                Relationship relationship = parseRelationshipResponse(resobj);
                relationships.add(relationship);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return relationships;
    }

    /**
     * Parse json response for the context
     *
     * @param jsonObject JSONObject
     * @return Context
     */
    private app.fedilab.android.client.Entities.Context parseContext(JSONObject jsonObject) {

        app.fedilab.android.client.Entities.Context context = new app.fedilab.android.client.Entities.Context();
        try {
            if (MainActivity.social == UpdateAccountInfoAsyncTask.SOCIAL.PIXELFED) {
                context.setAncestors(parseStatuses(this.context, jsonObject.getJSONArray("data")));
            } else {
                context.setAncestors(parseStatuses(this.context, jsonObject.getJSONArray("ancestors")));
                context.setDescendants(parseStatuses(this.context, jsonObject.getJSONArray("descendants")));
            }

        } catch (JSONException e) {
            setDefaultError(e);
        }
        return context;
    }

    /**
     * Parse json response for list of notifications
     *
     * @param jsonArray JSONArray
     * @return List<Notification>
     */
    private List<Notification> parseNotificationResponse(JSONArray jsonArray) {

        List<Notification> notifications = new ArrayList<>();
        try {
            int i = 0;
            while (i < jsonArray.length()) {

                JSONObject resobj = jsonArray.getJSONObject(i);
                Notification notification = parseNotificationResponse(context, resobj);
                notifications.add(notification);
                i++;
            }
        } catch (JSONException e) {
            setDefaultError(e);
        }
        return notifications;
    }

    /**
     * Set the error message
     *
     * @param statusCode int code
     * @param error      Throwable error
     */
    private void setError(int statusCode, Throwable error) {
        APIError = new Error();
        APIError.setStatusCode(statusCode);
        String message = statusCode + " - " + error.getMessage();
        try {
            JSONObject jsonObject = new JSONObject(Objects.requireNonNull(error.getMessage()));
            String errorM = jsonObject.getString("error");
            message = "Error " + statusCode + " : " + errorM;
        } catch (JSONException e) {
            if (error.getMessage().split(".").length > 0) {
                String errorM = error.getMessage().split(".")[0];
                message = "Error " + statusCode + " : " + errorM;
            }
        }
        APIError.setError(message);
        apiResponse.setError(APIError);
    }

    private void setDefaultError(Exception e) {
        APIError = new Error();
        if (apiResponse == null) {
            apiResponse = new APIResponse();
        }
        if (e.getLocalizedMessage() != null && e.getLocalizedMessage().trim().length() > 0)
            APIError.setError(e.getLocalizedMessage());
        else if (e.getMessage() != null && e.getMessage().trim().length() > 0)
            APIError.setError(e.getMessage());
        else
            APIError.setError(context.getString(R.string.toast_error));
        apiResponse.setError(APIError);
    }

    public Error getError() {
        return APIError;
    }

    private String getAbsoluteUrl(String action) {
        if (prefKeyOauthTokenT.startsWith("X-XSRF-TOKEN")) {
            return Helper.instanceWithProtocol(this.context, this.instance) + "/api/pixelfed/v1" + action;
        } else {
            return Helper.instanceWithProtocol(this.context, this.instance) + "/api/v1" + action;
        }

    }


    private String getAbsoluteUr2l(String action) {
        return Helper.instanceWithProtocol(this.context, this.instance) + "/api/v2" + action;
    }

    private String getAbsoluteUrlRemote(String remote, String action) {
        return "https://" + remote + "/api/v1" + action;
    }

    private String getAbsoluteUrlRemoteInstance(String instanceName) {
        return "https://" + instanceName + "/api/v1/timelines/public?local=true";
    }

    private String getAbsoluteUrlCommunitywiki(String action) {
        return "https://communitywiki.org/trunk/api/v1" + action;
    }

    public enum searchType {
        TAGS,
        STATUSES,
        ACCOUNTS
    }

    public enum adminAction {
        ENABLE,
        APPROVE,
        REJECT,
        NONE,
        SILENCE,
        DISABLE,
        UNSILENCE,
        SUSPEND,
        UNSUSPEND,
        ASSIGN_TO_SELF,
        UNASSIGN,
        REOPEN,
        RESOLVE,
        GET_ACCOUNTS,
        GET_ONE_ACCOUNT,
        GET_REPORTS,
        GET_ONE_REPORT
    }

    public enum StatusAction {
        FAVOURITE,
        UNFAVOURITE,
        BOOKMARK,
        UNBOOKMARK,
        REBLOG,
        UNREBLOG,
        MUTE,
        MUTE_NOTIFICATIONS,
        UNMUTE,
        MUTE_CONVERSATION,
        UNMUTE_CONVERSATION,
        BLOCK,
        UNBLOCK,
        FOLLOW,
        UNFOLLOW,
        NOTIFY_FOR_ACCOUNT,
        UNNOTIFY_FOR_ACCOUNT,
        CREATESTATUS,
        UNSTATUS,
        AUTHORIZE,
        REJECT,
        REPORT,
        REMOTE_FOLLOW,
        PIN,
        UNPIN,
        REACT,
        UNREACT,
        ENDORSE,
        UNENDORSE,
        SHOW_BOOST,
        HIDE_BOOST,
        BLOCK_DOMAIN,
        RATEVIDEO,
        PEERTUBECOMMENT,
        PEERTUBEREPLY,
        PEERTUBEDELETECOMMENT,
        PEERTUBEDELETEVIDEO,
        UPDATESERVERSCHEDULE,
        DELETESCHEDULED,
        REFRESHPOLL,
        ADD_REACTION,
        REMOVE_REACTION,
        ADD_PLEROMA_REACTION,
        REMOVE_PLEROMA_REACTION,
        DISMISS_ANNOUNCEMENT
    }

    public enum accountPrivacy {
        PUBLIC,
        LOCKED
    }

}