/**
 * Make gson which {@link DateDeserializer} and compatible with {@link RealmObject}
 * @return {@link Gson} object
 */
public static Gson makeGsonForRealm() {
    return makeDefaultGsonBuilder()
            .setExclusionStrategies(new ExclusionStrategy() {
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
                    return f.getDeclaringClass().equals(RealmObject.class);
                }

                @Override
                public boolean shouldSkipClass(Class<?> clazz) {
                    return false;
                }
            })
            .create();
}
 

@Override
public <Item extends RealmObject> Observable<List<Item>> getApiObservable(Observable<List<Item>> api, Class<Item> realmClass, String sortedField, List<Integer> ids) {
    if (getStorage() != null) {
        RealmResults<Item> realmResults;
        if (sortedField != null)
            realmResults = (ids == null) ? getItems(realmClass, sortedField) : getItems(realmClass, sortedField, ids);
        else
            realmResults = getItems(realmClass);
        Observable<List<Item>> realmObserver = realmResults.asObservable()
                .filter(RealmResults::isLoaded)
                .compose(getLifecycle())
                .switchMap(Observable::just);
        Observable<List<Item>> retrofitObserver = api
                .compose(applySchedulers())
                .compose(getLifecycle());
        return Observable.<List<Item>>create(subscriber -> {
            realmObserver.take(2).subscribe(subscriber::onNext, subscriber::onError, subscriber::onCompleted);
            retrofitObserver.subscribe(this::setItems, subscriber::onError);
        }).compose(getLifecycle());
    } else
        return api;
}
 

public static void checkTreatmentDateDuplicated(Class clazz, PumpHistoryInterface record, TreatmentsEndpoints.Treatment treatment) {
    long timestamp = record.getEventDate().getTime();
    String key = record.getKey();

    RealmResults results = RealmObject.getRealm(record).where(clazz)
            .greaterThan("eventDate", new Date(timestamp - 2000L))
            .lessThan("eventDate", new Date(timestamp + 2000L))
            .findAll();

    if (key != null && results.size() > 1) {
        Log.w(TAG, "found " + results.size() + " events with the same date");
        int n = 0;
        while (n < results.size()
                && ((PumpHistoryInterface) results.get(n)).getKey() != null
                && !(((PumpHistoryInterface) results.get(n)).getKey().equals(key))
        ) {n++;}
        if (n > 0) {
            Log.w(TAG, String.format("adjusted eventDate for nightscout +%s seconds", n * 2));
            treatment.setCreated_at(new Date(timestamp + n * 2000));
        }
    }
}
 

/**
 * Custom Gson to make Retrofit Gson adapter work with Realm objects
 */
@NonNull
@Provides
@Singleton
public static Gson provideGson(@NonNull ListTypeAdapterFactory jsonArrayTypeAdapterFactory,
                               @NonNull HtmlAdapter htmlAdapter,
                               @NonNull StringCapitalizerAdapter stringCapitalizerAdapter) {

    return new GsonBuilder()
            .setExclusionStrategies(new ExclusionStrategy() {
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
                    return f.getDeclaringClass().equals(RealmObject.class);
                }

                @Override
                public boolean shouldSkipClass(Class<?> clazz) {
                    return false;
                }
            })
            .registerTypeAdapterFactory(jsonArrayTypeAdapterFactory)
            .registerTypeAdapter(String.class, htmlAdapter)
            .registerTypeAdapter(String.class, stringCapitalizerAdapter)
            .create();
}
 

public <E extends RealmObject> void deleteAllIn(Class<E> classType, String classField,
    String[] fieldsIn) {
  Realm realm = get();
  try {
    realm.beginTransaction();
    realm.where(classType)
        .in(classField, fieldsIn)
        .findAll()
        .deleteAllFromRealm();
    realm.commitTransaction();
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <E extends RealmObject> void deleteAllExcluding(Class<E> classType, String classField,
    List<String> fieldsIn) {
  Realm realm = get();
  try {
    realm.beginTransaction();
    RealmQuery<E> query = realm.where(classType);
    for (String field : fieldsIn) {
      query.notEqualTo(classField, field);
    }
    query.findAll()
        .deleteAllFromRealm();
    realm.commitTransaction();
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <T extends RealmObject> void deleteAll(Class<T> clazz) {
    final RealmResults results = mRealm.where(clazz).findAll();
    mRealm.executeTransaction(new Realm.Transaction() {
        @Override
        public void execute(Realm realm) {
            results.deleteAllFromRealm();

        }
    });
}
 

public <T extends RealmObject> void deleteTopicMessage(Class<T> clazz, String topic) {
    final RealmResults results = mRealm.where(clazz)
            .equalTo("topic", topic)
            .findAll();
    mRealm.executeTransaction(new Realm.Transaction() {
        @Override
        public void execute(Realm realm) {
            results.deleteAllFromRealm();

        }
    });
}
 

public <T extends RealmObject> void deleteTopic(Class<T> clazz, String id) {
    final RealmResults results = mRealm.where(clazz)
            .equalTo("connectionId", id)
            .findAll();
    mRealm.executeTransaction(new Realm.Transaction() {
        @Override
        public void execute(Realm realm) {
            results.deleteAllFromRealm();

        }
    });
}
 

public <E extends RealmObject> Observable<E> findFirst(RealmQuery<E> query) {
  return Observable.just(query.findFirst())
      .filter(realmObject -> realmObject != null)
      .flatMap(realmObject -> realmObject.<E>asObservable().unsubscribeOn(
          RealmSchedulers.getScheduler()))
      .flatMap(realmObject -> copyFromRealm(realmObject))
      .defaultIfEmpty(null);
}
 

private <E extends RealmObject> Observable<E> copyFromRealm(E object) {
  return Observable.just(object)
      .filter(data -> data.isLoaded())
      .filter(realmObject -> realmObject.isValid())
      .map(realmObject -> get().copyFromRealm(realmObject))
      .observeOn(Schedulers.io());
}
 

public <E extends RealmObject> Observable<List<E>> findAsList(RealmQuery<E> query) {
  return Observable.just(query.findAll())
      .filter(realmObject -> realmObject != null)
      .flatMap(realmObject -> realmObject.<E>asObservable().unsubscribeOn(
          RealmSchedulers.getScheduler()))
      .flatMap(realmObject -> copyFromRealm(realmObject))
      .defaultIfEmpty(null);
}
 

public <E extends RealmObject> void delete(Class<E> clazz, String key, String value) {
  Realm realm = get();
  try {
    E obj = realm.where(clazz)
        .equalTo(key, value)
        .findFirst();
    deleteObject(realm, obj);
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <E extends RealmObject> void deleteObject(Realm realm, E obj) {
  realm.beginTransaction();
  try {
    if (obj != null && obj.isValid()) {
      obj.deleteFromRealm();
      realm.commitTransaction();
    } else {
      realm.cancelTransaction();
    }
  } catch (Exception ex) {
    CrashReport.getInstance()
        .log(ex);
    realm.cancelTransaction();
  }
}
 

public <E extends RealmObject> void delete(Class<E> clazz, String key, Integer value) {
  Realm realm = get();
  try {
    E obj = realm.where(clazz)
        .equalTo(key, value)
        .findFirst();
    deleteObject(realm, obj);
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <E extends RealmObject> void delete(Class<E> clazz, String key, Long value) {
  Realm realm = get();
  try {
    E obj = realm.where(clazz)
        .equalTo(key, value)
        .findFirst();
    deleteObject(realm, obj);
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <E extends RealmObject> void deleteAll(Class<E> clazz) {
  Realm realm = get();
  try {
    realm.beginTransaction();
    realm.delete(clazz);
    realm.commitTransaction();
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <E extends RealmObject> void insertAll(List<E> objects) {
  Realm realm = get();
  try {
    realm.beginTransaction();
    realm.insertOrUpdate(objects);
    realm.commitTransaction();
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

public <E extends RealmObject> void insert(E object) {
  Realm realm = get();
  try {
    realm.beginTransaction();
    realm.insertOrUpdate(object);
    realm.commitTransaction();
  } finally {
    if (realm != null) {
      realm.close();
    }
  }
}
 

@NonNull
public static <T extends RealmObject, A extends Accessor> A getAccessorFor(Database database,
    Class<T> clazz) {
  if (clazz.equals(Store.class)) {
    return (A) new StoreAccessor(database);
  }

  throw new RuntimeException("Create accessor for class " + clazz.getName());
}
 

private static GsonBuilder getBuilder() {
    return new GsonBuilder()
            .setExclusionStrategies(new ExclusionStrategy() {
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
                    return f.getDeclaringClass().equals(RealmObject.class);
                }

                @Override
                public boolean shouldSkipClass(Class<?> clazz) {
                    return false;
                }
            });
}
 

/**
 * Get the api singleton from the api interface
 *
 * @return api
 */
@Override
public Api getApi() {
    if (mApi == null) {
        mApi = new Retrofit.Builder()
                .client(new OkHttpClient.Builder()
                        .addInterceptor(API_KEY_INTERCEPTOR)
                        .build())
                .baseUrl(mApiBaseUrl)
                .addConverterFactory(GsonConverterFactory.create(getGsonBuilder(new GsonBuilder())
                        .setExclusionStrategies(new ExclusionStrategy() {
                            @Override
                            public boolean shouldSkipField(FieldAttributes f) {
                                return f.getDeclaringClass().equals(RealmObject.class);
                            }

                            @Override
                            public boolean shouldSkipClass(Class<?> clazz) {
                                return false;
                            }
                        })
                        .create()))
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build()
                .create(mClazz);
    }
    return mApi;
}
 

@Override
public <Item extends RealmObject> RealmResults<Item> getItems(Class<Item> objectClass, String sortedFieldName, List<Integer> ids) {
    RealmQuery<Item> query = getQuery(objectClass);
    for (int i = 0; i < ids.size() - 1; i++) {
        query = query.equalTo(sortedFieldName, ids.get(i)).or();
    }
    query = query.equalTo(sortedFieldName, ids.get(ids.size() - 1));

    return query.findAllSortedAsync(sortedFieldName);
}
 

@Override
public <Item extends RealmObject> Observable<List<Item>> getApiObservable(Observable<List<Item>> api, Class<Item> realmClass, String sortedField) {
    return getApiObservable(api, realmClass, sortedField, null);
}
 

public <T extends RealmObject> T queryFirst(Class<T> clazz) {
    return mRealm.where(clazz).findFirst();
}
 

public <T extends RealmObject> RealmResults<T> queryAll(Class<T> clazz) {
    return mRealm.where(clazz).findAll();
}
 

public <T extends RealmObject> RealmResults<T> queryTopicMessage(Class<T> clazz, String topic) {
    return mRealm.where(clazz).equalTo("topic", topic).findAll();
}
 

public <T extends RealmObject> T queryFirstTopicMessage(Class<T> clazz, String topic) {
    return mRealm.where(clazz).equalTo("topic", topic).findFirst();
}
 

public <T extends RealmObject> void delete(T data) {
    mRealm.beginTransaction();
    data.deleteFromRealm();
    mRealm.commitTransaction();
}
 

/**
 * see {@link #initFindAllSorted(RealmQuery, List)}
 */
public static <T extends RealmObject> RealmResults<T> initFindAllSorted(RealmQuery<T> query) throws Exception {
    return initFindAllSorted(query, null);
}