package com.nimbits;

import com.nimbits.client.NimbitsClient;
import com.nimbits.client.NimbitsClientFactory;
import com.nimbits.client.model.Action;
import com.nimbits.client.model.Const;
import com.nimbits.client.model.common.CommonFactoryLocator;
import com.nimbits.client.model.email.EmailAddress;
import com.nimbits.client.model.point.PointName;
import com.nimbits.client.model.value.Value;
import com.nimbits.client.model.value.ValueModelFactory;
import com.nimbits.console.KeyFile;
import com.nimbits.gson.GsonFactory;
import com.nimbits.user.GoogleUser;
import com.nimbits.user.NimbitsUser;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by bsautner
 * User: benjamin
 * Date: 4/8/11
 * Time: 2:42 PM
 */
public class MainClass {

    public static void main(final String[] args) throws IOException {
        final HashMap<String, String> argsMap = new HashMap<String, String>();

        if (args == null || args.length == 0) {
            printUsage();
            return;
        } else {
            processArgs(args, argsMap);
        }

        if (argsMap.containsKey(Const.PARAM_I)) {
            String[] fileArgs = KeyFile.processKeyFile(argsMap);
            processArgs(fileArgs, argsMap);
        }


        final boolean verbose = argsMap.containsKey(Const.PARAM_VERBOSE);
        final String host = argsMap.containsKey(Const.PARAM_HOST) ? argsMap.get(Const.PARAM_HOST) : Const.PATH_NIMBITS_PUBLIC_SERVER;
        final String emailParam = argsMap.containsKey(Const.PARAM_EMAIL) ? argsMap.get(Const.PARAM_EMAIL) : null;
        final String key = argsMap.containsKey(Const.PARAM_KEY) ? argsMap.get(Const.PARAM_KEY) : null;
        final String password = argsMap.containsKey(Const.PARAM_PASSWORD) ? argsMap.get(Const.PARAM_PASSWORD) : null;
        final EmailAddress email = CommonFactoryLocator.getInstance().createEmailAddress(emailParam);
        final NimbitsClient client = createClient(host, email, key, password);

        final boolean loggedIn = checkLoggedIn(client, verbose);

        if (!loggedIn) {
            out(true, "Access Denied.");
            return;
        }

        if (argsMap.containsKey(Const.PARAM_ACTION) && loggedIn) {
            Action action = Action.valueOf(argsMap.get(Const.PARAM_ACTION));

            switch (action) {
                case read:
                case readvalue:
                case readgps:
                case readjson:
                case readnote:
                    readValue(client, argsMap, action);
                    break;
                case record:
                case recordvalue:
                    recordValue(client, argsMap, verbose);
                    break;
                default:
                    printUsage();
            }
        } else if (argsMap.containsKey(Const.PARAM_GENKEY) && argsMap.containsKey(Const.PARAM_OUT)) {

            out(true, KeyFile.genKey(argsMap));

        }


    }

    private static void readValue(final NimbitsClient client, final Map<String, String> argsMap, Action action) {
        final PointName pointName = CommonFactoryLocator.getInstance().createPointName(argsMap.get(Const.PARAM_POINT));
        final Value v = client.getCurrentRecordedValue(pointName);

        switch (action) {
            case read:
            case readvalue:
                out(true, String.valueOf(v.getValue()));
                break;
            case readgps:
                out(true, v.getLatitude() + "," + v.getLongitude());
                break;
            case readnote:
                out(true, v.getNote());
                break;
            case readjson:
                out(true, GsonFactory.getInstance().toJson(v));
                break;
        }
    }

    private static Value buildValue(final Map<String, String> argsMap) {
        final double d = argsMap.containsKey(Const.PARAM_VALUE) ? Double.valueOf(argsMap.get(Const.PARAM_VALUE)) : 0.0;
        final String note = argsMap.containsKey(Const.PARAM_NOTE) ? argsMap.get(Const.PARAM_NOTE) : null;
        final double lat = argsMap.containsKey(Const.PARAM_LAT) ? Double.valueOf(argsMap.get(Const.PARAM_LAT)) : 0.0;
        final double lng = argsMap.containsKey(Const.PARAM_LNG) ? Double.valueOf(argsMap.get(Const.PARAM_LNG)) : 0.0;
        return ValueModelFactory.createValueModel(lat, lng, d, new Date(), 0, note, "");

    }

    private static void recordValue(final NimbitsClient client, final Map<String, String> argsMap, final boolean verbose) throws IOException {
        out(verbose, "Recording values");

        final Value v = buildValue(argsMap);
        final PointName pointName = CommonFactoryLocator.getInstance().createPointName(argsMap.get(Const.PARAM_POINT));
        final Value result = client.recordValue(pointName, v);
        if (result == null) {
            out(verbose, "An error occurred recording your data");
        } else {
            out(verbose, result.getValue() + " recorded to " + pointName);
        }
    }

    private static boolean checkLoggedIn(final NimbitsClient client, final boolean verbose) throws IOException {
        boolean loggedIn = false;
        if (client != null) {
            out(verbose, "Authenticating...");
            loggedIn = client.isLoggedIn();
            if (loggedIn) {
                out(verbose, "Success");
            } else {
                out(verbose, "Authentication Failure");
            }
        }
        return loggedIn;
    }

    private static NimbitsClient createClient(final String host, final EmailAddress email, final String key, final String password) {
        NimbitsClient client = null;

        if (key != null && email != null) {
            NimbitsUser n = new NimbitsUser(email, key);
            client = NimbitsClientFactory.getInstance(n, host);
        } else if (password != null && email != null) {
            GoogleUser g = new GoogleUser(email, password);
            try {
                client = NimbitsClientFactory.getInstance(g, host);
            } catch (Exception e) {

                out(true, e.getMessage());
            }
        }
        return client;
    }

    private static void processArgs(final String[] args, final Map<String, String> argsMap) {
        for (String s : args) {

            String[] a = s.split("=");
            if (a.length == 2) {
                argsMap.put(a[0].replaceFirst("-", "").toLowerCase(), a[1].trim());
            } else {
                argsMap.put(s.replaceFirst("-", "").toLowerCase(), "");
            }


        }
    }

    private static void out(boolean verbose, final String message) {
        if (verbose) {
            System.out.println(message);
        }
    }

    private static void printUsage() {
        out(true, "Unexpected parameters. Please refer to the SDK Manual on www.nimbits.com.");
    }

}