package com.basic.security.manager.impl.cblite;

import android.text.TextUtils;

import com.basic.security.manager.impl.sqlite.SlBaseManager;
import com.basic.security.model.ModelAdapter;
import com.basic.security.utils.Constants;
import com.basic.security.utils.Page;
import com.couchbase.lite.DataSource;
import com.couchbase.lite.Database;
import com.couchbase.lite.Document;
import com.couchbase.lite.Expression;
import com.couchbase.lite.Meta;
import com.couchbase.lite.OrderBy;
import com.couchbase.lite.Ordering;
import com.couchbase.lite.Query;
import com.couchbase.lite.QueryBuilder;
import com.couchbase.lite.Result;
import com.couchbase.lite.ResultSet;
import com.couchbase.lite.SelectResult;
import com.couchbase.lite.Where;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

public class BaseManager {


    protected static void saveMutableDocumentOnly1(ModelAdapter modelAdapter) {
        try {
            database.save(modelAdapter.couchbaseModel);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected static void save(ModelAdapter modelAdapter) {
        try {
            database.save(modelAdapter.couchbaseModel);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected static void delete(ModelAdapter modelAdapter) {
        try {
            database.delete(modelAdapter.couchbaseModel);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @SuppressWarnings("all")
    protected static ModelAdapter findOne(Expression expression) {
        return findOne(expression, new Ordering[0]);
    }

    protected static ModelAdapter findOne(Expression expression, String sql) {
        if (Constants.useCouchbase) {
            return findOne(expression, new Ordering[0]);
        } else {
            return SlBaseManager.findOne(sql);
        }
    }

    protected static ModelAdapter findOne(Expression expression, Ordering... orderings) {
        ModelAdapter modelAdapter = new ModelAdapter();
        try {
            Map<String, Object> fields = new HashMap<>();
            if (database == null) {
                return modelAdapter;
            }
            Query query = QueryBuilder.select(SelectResult.all(), (SelectResult.expression(Meta.id)))
                    .from(DataSource.database(database))
                    .where(expression);
            if (orderings != null && orderings.length > 0) {
                query = ((Where) query).orderBy(orderings)
                        .limit(Expression.intValue(1));
            }
            ResultSet rows = query.execute();
            Result row = null;
            if ((row = rows.next()) != null) {
                List columns = row.toList();
                if (columns.size() == 2) {
                    if (columns.get(1) != null) {
                        modelAdapter = new ModelAdapter(database.getDocument(columns.get(1) + "").toMutable());
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return modelAdapter;
    }

    protected static List<ModelAdapter> findList(Expression expression) {
        return findList(expression, null);
    }

    protected static List<ModelAdapter> findList(Expression expression, Ordering[] orderings) {
        return findList(expression, orderings, null, null);
    }

    protected static List<ModelAdapter> findList(Expression expression, Ordering[] orderings, Integer limit) {
        return findList(expression, orderings, limit, null);
    }

    protected static int count(Expression expression) {
        try {
            if (database == null) {
                return 0;
            }
            Query query = QueryBuilder.select(SelectResult.all(), (SelectResult.expression(Meta.id)))
                    .from(DataSource.database(database))
                    .where(expression);
            ResultSet rows = query.execute();
            return rows.allResults().size();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    protected static Page findPage(Expression expression, Integer pageSize, Integer pageNo) {
        return findPage(expression, null, pageSize, pageNo);
    }

    protected static Page findPage(Expression expression, Ordering[] orderings, Integer pageSize, Integer pageNo) {
        int total = count(expression);
        List<ModelAdapter> data = findList(expression, orderings, pageSize, (pageNo - 1) * pageSize);
        return new Page(total, data);
    }

    protected static List<ModelAdapter> findList(Expression expression, Ordering[] orderings, Integer limit, Integer offset) {
        List<ModelAdapter> modelAdapterList = new Vector<>();
        try {
            if (database == null) {
                return modelAdapterList;
            }
            Query query = QueryBuilder.select((SelectResult.expression(Meta.id)))
                    .from(DataSource.database(database))
                    .where(expression);
            boolean hasOrdering = orderings != null && orderings.length > 0;
            if (hasOrdering) {
                query = ((Where) query).orderBy(orderings);
            }
            if (limit != null) {
                if (offset != null) {
                    if (hasOrdering) {
                        query = ((OrderBy) query).limit(Expression.intValue(limit), Expression.intValue(offset));
                    } else {
                        query = ((Where) query).limit(Expression.intValue(limit), Expression.intValue(offset));
                    }
                } else {
                    if (hasOrdering) {
                        query = ((OrderBy) query).limit(Expression.intValue(limit));
                    } else {
                        query = ((Where) query).limit(Expression.intValue(limit));
                    }
                }
            }
            ResultSet rows = query.execute();
            Result row = null;

            while ((row = rows.next()) != null) {
                List columns = row.toList();
                ModelAdapter modelAdapter = new ModelAdapter(database.getDocument((String) columns.get(0)).toMutable());
                if (modelAdapter != null) {
                    modelAdapterList.add(modelAdapter);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return modelAdapterList;
    }

    protected static void deleteList(List<ModelAdapter> documentList) {
        for (ModelAdapter document : documentList) {
            delete(document);
        }
    }

    protected static ModelAdapter findById(String id) {
        if (TextUtils.isEmpty(id)) {
            return null;
        }
        Document document = database.getDocument(id);
        if (document != null) {
            return new ModelAdapter(document.toMutable());
        }
        return null;
    }

    private static Database database;
    public static void setDatabase(Database database) {
        BaseManager.database = database;
    }

}