package lv.lu.fileshare.svc;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Logger;

import lv.lu.fileshare.UploadedFile;
import lv.lu.fileshare.UserInfo;
import lv.lu.fileshare.Utils;

import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.EntityNotFoundException;
import com.google.appengine.api.datastore.FetchOptions;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import com.google.appengine.api.datastore.PreparedQuery;
import com.google.appengine.api.datastore.Query;
import com.google.appengine.api.datastore.Transaction;
import com.google.appengine.api.datastore.TransactionOptions;
import com.google.appengine.api.datastore.Query.FilterOperator;
import com.google.appengine.api.datastore.Query.SortDirection;

public class GaeDatastoreDataService implements DataService {
    private static final String KIND_USER = "User";
    private static final String KIND_USER_GRP = "UserGroup";
    private static final String KIND_NICK_GRP = "NickGroup";
    private static final String KIND_FILE = "File";
    private static final String KIND_NICK = "Nick";

    private final static Logger logger = Logger.getLogger(GaeDatastoreDataService.class.getName());

    private Transaction t;

    DatastoreService datastore;

    public GaeDatastoreDataService() {
        datastore =
                DatastoreServiceFactory.getDatastoreService();
    }

    public void beginTransaction() {
        t = null;
        logger.info("beginTransaction" + this);
        t = datastore.beginTransaction(TransactionOptions.Builder.withDefaults().setXG(true));
    }

    public void endTransaction() {
        logger.info("endTransaction" + this);
        if (t!= null && t.isActive()) {
            t.rollback();
        }
        t = null;
    }

    public void commitTransaction() {
        logger.info("commitTransaction" + this);
        t.commit();
        t = null;
    }

    public UserInfo loginCheck(String email, String pass, boolean ignorePass) {
        Query query = null;

        query = new Query(KIND_USER_GRP).addFilter("name", FilterOperator.EQUAL, calcUserGroupName(email));

        Entity userGrpEnt = datastore.prepare(query).asSingleEntity();

        if (userGrpEnt == null) {
            throw new RuntimeException("user group missing");
        }

        query = new Query(KIND_USER).addFilter("email", FilterOperator.EQUAL, email).setAncestor(userGrpEnt.getKey());

        Entity userEnt = datastore.prepare(query).asSingleEntity();

        if (userEnt == null) return null;

        final String realPass = (String)userEnt.getProperty("pass");

        if (ignorePass || Utils.calcMd5(pass).equals(realPass)) { // ignorePass - logojoties caur google
            return new UserInfo(email, (String)userEnt.getProperty("nick"), userEnt.getKey());
        } else {
            return null;
        }
    }

    // be sure that email&nick is unused before call this
    public void registerAccount(String email, String nick, String pass) {
        Query query = null;

        query = new Query(KIND_USER_GRP).addFilter("name", FilterOperator.EQUAL, calcUserGroupName(email));

        Entity userGrpEnt = datastore.prepare(query).asSingleEntity();

        Entity usrEnt = new Entity(KIND_USER, userGrpEnt.getKey());
        usrEnt.setProperty("nick", nick);
        usrEnt.setProperty("email", email);
        usrEnt.setProperty("pass", pass == null ? null : Utils.calcMd5(pass));

        final Key nickGrpKey = KeyFactory.createKey(KIND_NICK_GRP, calcNickGroupName(nick));
        Entity nickEnt = new Entity(KIND_NICK, nickGrpKey);
        nickEnt.setProperty("name", nick);

        datastore.put(usrEnt);
        datastore.put(nickEnt);
    }

    public void editProfile(String newNick, String oldNick, String newPass, String emailRo) {
        // saving changes & reserving nick

        final Key userGrpKey = KeyFactory.createKey(KIND_USER_GRP, calcUserGroupName(emailRo));
        Query query = new Query(KIND_USER).addFilter("email", FilterOperator.EQUAL, emailRo).setAncestor(userGrpKey);
        Entity userEnt = datastore.prepare(query).asSingleEntity();

        if (newPass != null && !newPass.equals("")) {
            userEnt.setProperty("pass", Utils.calcMd5(newPass));
        }
        userEnt.setProperty("nick", newNick);

        // userEnt != NULL always

        datastore.put(userEnt);

        if (!newNick.equals(oldNick)) {
            final Key nickGrpKey = KeyFactory.createKey(KIND_NICK_GRP, calcNickGroupName(newNick));
            Entity nickEnt = new Entity(KIND_NICK, nickGrpKey);
            nickEnt.setProperty("name", newNick);
            datastore.put(nickEnt);

            final Key oldNickGrpKey = KeyFactory.createKey(KIND_NICK_GRP, calcNickGroupName(oldNick));
            query = new Query(KIND_NICK).addFilter("name", FilterOperator.EQUAL, oldNick).setAncestor(oldNickGrpKey);
            Entity oldNickEnt = datastore.prepare(query).asSingleEntity();

            // oldNickEnt!=null always
            // release old nick
            datastore.delete(oldNickEnt.getKey());
        }
    }

    @Override
    public boolean emailAvailable(String email) {
        Query query = null;

        query = new Query(KIND_USER_GRP).addFilter("name", FilterOperator.EQUAL, calcUserGroupName(email));

        Entity userGrpEnt = datastore.prepare(query).asSingleEntity();

        if (userGrpEnt == null) {
            throw new RuntimeException("user group missing");
        }

        query = new Query(KIND_USER).addFilter("email", FilterOperator.EQUAL, email).setAncestor(userGrpEnt.getKey());

        Entity userEnt = datastore.prepare(query).asSingleEntity();
        return userEnt == null;
    }

    private String calcUserGroupName(String email) {
        // TODO: implementēt dalīšanu vairākās kastēs
        return "BigBox";
    }

    private String calcNickGroupName(String nick) {
        // TODO: implementēt dalīšanu vairākās kastēs
        return "BigNickBox";
    }

    @Override
    public void install() {
        Entity emailBox = new Entity(KIND_USER_GRP, "BigBox");
        emailBox.setProperty("name", "BigBox");
        datastore.put(emailBox);

        Entity nickBox = new Entity(KIND_NICK_GRP, "BigNickBox");
        nickBox.setProperty("name", "BigNickBox");
        datastore.put(nickBox);
    }

    public boolean nickAvailable(String nick) {
        final Key nickBoxKey = KeyFactory.createKey(KIND_NICK_GRP, calcNickGroupName(nick));

        Query query;
        query = new Query(KIND_NICK).addFilter("name", FilterOperator.EQUAL, nick).setAncestor(nickBoxKey);

        Entity nickEnt = datastore.prepare(query).asSingleEntity();
        return nickEnt == null;
    }

    @Override
    public void registerFile(Key userKey, String filename, long filesize) {
        final Entity file = new Entity(KIND_FILE, userKey);
        file.setProperty("filename", filename);
        file.setProperty("filesize", filesize);
        file.setProperty("filedate", new Date());

        datastore.put(file);
    }

    @Override
    public List<UploadedFile> getUserFiles(final Key userKey) {
        Query query = null;

        query = new Query(KIND_FILE).setAncestor(userKey);
        query.addSort("filedate", SortDirection.DESCENDING);

        final PreparedQuery pq = datastore.prepare(query);
        final List<Entity> fileEnts = pq.asList(FetchOptions.Builder.withLimit(1000)); // TODO: pa lapām

        final List<UploadedFile> result = new ArrayList<UploadedFile>();

        for (Entity ent : fileEnts) {
            result.add(new UploadedFile((String)ent.getProperty("filename"), (Long)ent.getProperty("filesize"), (Date)ent.getProperty("filedate")));
        }

        return result;
    }

    @Override
    public List<UploadedFile> getAllFiles() {
        Query query = null;

        query = new Query(KIND_FILE);
        query.addSort("filedate", SortDirection.DESCENDING);

        final PreparedQuery pq = datastore.prepare(query);
        final List<Entity> fileEnts = pq.asList(FetchOptions.Builder.withLimit(1000)); // TODO: pa lapām

        final List<UploadedFile> result = new ArrayList<UploadedFile>();

        for (Entity ent : fileEnts) {
            final Key uploaderKey = ent.getParent();

            Entity uploaderEnt;
            try {
                uploaderEnt = datastore.get(uploaderKey);
            } catch (EntityNotFoundException e) {
                uploaderEnt = null;
            }

            UploadedFile f = new UploadedFile((String)ent.getProperty("filename"), (Long)ent.getProperty("filesize"), (Date)ent.getProperty("filedate"));

            f.setUploader(uploaderEnt == null ? "" : (String) uploaderEnt.getProperty("nick"));

            result.add(f);
        }

        return result;
    }

    @Override
    public void test() {
    }
}