/*
 * Copyright 2010 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.requestfactory.client.impl;

import com.google.gwt.core.client.GWT;
import com.google.gwt.event.shared.EventBus;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.requestfactory.client.RequestFactoryLogHandler;
import com.google.gwt.requestfactory.shared.RequestEvent;
import com.google.gwt.requestfactory.shared.RequestFactory;
import com.google.gwt.requestfactory.shared.RequestObject;
import com.google.gwt.requestfactory.shared.RequestEvent.State;
import com.google.gwt.user.client.Window.Location;
import com.google.gwt.valuestore.shared.Record;
import com.google.gwt.valuestore.shared.WriteOperation;

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * <p>
 * <span style="color:red">Experimental API: This class is still under rapid
 * development, and is very likely to be deleted. Use it at your own risk.
 * </span>
 * </p>
 * Base implementation of RequestFactory.
 */
public abstract class RequestFactoryJsonImpl implements RequestFactory {

  static final boolean IS_FUTURE = true;
  static final boolean NOT_FUTURE = false;
  private static Logger logger = Logger.getLogger(RequestFactory.class.getName());

  // A separate logger for wire activity, which does not get logged by the
  // remote log handler, so we avoid infinite loops. All log messages that
  // could happen every time a request is made from the server should be logged
  // to this logger.
  private static Logger wireLogger = Logger.getLogger("WireActivityLogger");

  private static String SERVER_ERROR = "Server Error";

  private static final Integer INITIAL_VERSION = 1;

  private long currentFutureId = 0;

  private ValueStoreJsonImpl valueStore;

  private EventBus eventBus;

  public <R extends Record> R create(Class<R> token,
      RecordToTypeMap recordToTypeMap) {

    RecordSchema<R> schema = recordToTypeMap.getType(token);
    if (schema == null) {
      throw new IllegalArgumentException("Unknown proxy type: " + token);
    }

    return createFuture(schema);
  }

  public void fire(final RequestObject<?> requestObject) {
    RequestBuilder builder = new RequestBuilder(RequestBuilder.POST,
        GWT.getHostPageBaseURL() + RequestFactory.URL);
    builder.setHeader("Content-Type", RequestFactory.JSON_CONTENT_TYPE_UTF8);
    builder.setHeader("pageurl", Location.getHref());
    builder.setRequestData(ClientRequestHelper.getRequestString(requestObject.getRequestData().getRequestMap(
        ((AbstractRequest<?, ?>) requestObject).deltaValueStore.toJson())));
    builder.setCallback(new RequestCallback() {

      public void onError(Request request, Throwable exception) {
        postRequestEvent(State.RECEIVED, null);
        wireLogger.log(Level.SEVERE, SERVER_ERROR, exception);
      }

      public void onResponseReceived(Request request, Response response) {
        wireLogger.finest("Response received");
        if (200 == response.getStatusCode()) {
          String text = response.getText();
          ((AbstractRequest<?, ?>) requestObject).handleResponseText(text);
        } else if (Response.SC_UNAUTHORIZED == response.getStatusCode()) {
          wireLogger.finest("Need to log in");
        } else if (response.getStatusCode() > 0) {
          // During the redirection for logging in, we get a response with no
          // status code, but it's not an error, so we only log errors with
          // bad status codes here.
          wireLogger.severe(SERVER_ERROR + " " + response.getStatusCode() + " "
              + response.getText());
        }
        postRequestEvent(State.RECEIVED, response);
      }

    });

    try {
      wireLogger.finest("Sending fire request");
      builder.send();
      postRequestEvent(State.SENT, null);
    } catch (RequestException e) {
      wireLogger.log(Level.SEVERE, SERVER_ERROR + " (" + e.getMessage() + ")",
          e);
    }
  }

  public Class<? extends Record> getClass(Record proxy) {
    return ((RecordImpl) proxy).getSchema().getProxyClass();
  }

  public abstract RecordSchema<?> getSchema(String token);

  /**
   * @param eventBus
   */
  public void init(EventBus eventBus) {
    this.valueStore = new ValueStoreJsonImpl();
    this.eventBus = eventBus;
    Logger.getLogger("").addHandler(
        new RequestFactoryLogHandler(this, Level.WARNING, wireLogger.getName()));
    logger.fine("Successfully initialized RequestFactory");
  }

  protected Class<? extends Record> getClass(String token,
      RecordToTypeMap recordToTypeMap) {
    String[] bits = token.split("-");
    RecordSchema<? extends Record> schema = recordToTypeMap.getType(bits[0]);
    if (schema == null) {
      return null;
    }
    return schema.getProxyClass();
  }

  protected Record getProxy(String token, RecordToTypeMap recordToTypeMap) {
    String[] bits = token.split("-");
    if (bits.length < 2 || bits.length > 3) {
      return null;
    }

    RecordSchema<? extends Record> schema = recordToTypeMap.getType(bits[0]);
    if (schema == null) {
      return null;
    }

    if (bits.length == 3) {
      return createFuture(schema);
    }

    Long id = null;
    try {
      id = Long.valueOf(bits[1]);
    } catch (NumberFormatException e) {
      return null;
    }

    return schema.create(RecordJsoImpl.create(id, -1, schema));
  }

  protected String getToken(Record record, RecordToTypeMap recordToTypeMap) {
    Class<? extends Record> proxyClass = ((RecordImpl) record).getSchema().getProxyClass();
    String rtn = recordToTypeMap.getClassToken(proxyClass) + "-";
    if (((RecordImpl) record).isFuture()) {
      rtn += "0-FUTURE";
    } else {
      rtn += record.getId();
    }
    return rtn;
  }

  ValueStoreJsonImpl getValueStore() {
    return valueStore;
  }

  void postChangeEvent(RecordJsoImpl newJsoRecord, WriteOperation op) {
    /*
     * Ensure event receivers aren't accidentally using cached info by making an
     * unpopulated copy of the record.
     */
    newJsoRecord = RecordJsoImpl.emptyCopy(newJsoRecord);
    Record javaRecord = newJsoRecord.getSchema().create(newJsoRecord);
    eventBus.fireEvent(newJsoRecord.getSchema().createChangeEvent(javaRecord,
        op));
  }

  private <R extends Record> R createFuture(RecordSchema<R> schema) {
    Long futureId = ++currentFutureId;
    RecordJsoImpl newRecord = RecordJsoImpl.create(futureId, INITIAL_VERSION,
        schema);
    return schema.create(newRecord, IS_FUTURE);
  }

  private void postRequestEvent(State received, Response response) {
    eventBus.fireEvent(new RequestEvent(received, response));
  }
}