// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.sdk.internal.transport;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A transport message encapsulating the data sent/received over the wire
 * (protocol headers and content). This class can serialize and deserialize
 * itself into a BufferedWriter according to the ChromeDevTools Protocol
 * specification.
 */
public class Message {

  /**
   * This exception is thrown during Message deserialization whenever the input
   * is malformed.
   */
  public static class MalformedMessageException extends Exception {

    private static final long serialVersionUID = 1L;

    public MalformedMessageException() {
      super();
    }

    public MalformedMessageException(String message) {
      super(message);
    }

    public MalformedMessageException(Throwable cause) {
      super(cause);
    }

    public MalformedMessageException(String message, Throwable cause) {
      super(message, cause);
    }

  }

  /**
   * Known ChromeDevTools Protocol headers (ToolHandler implementations
   * can add their own headers.)
   */
  public enum Header {
    CONTENT_LENGTH("Content-Length"),
    TOOL("Tool"),
    DESTINATION("Destination"), ;

    public final String name;

    Header(String value) {
      this.name = value;
    }
  }

  /**
   * The class logger.
   */
  private static final Logger LOGGER = Logger.getLogger(Message.class.getName());

  /**
   * The end of protocol header line.
   */
  private static final String HEADER_TERMINATOR = "\r\n";

  private final HashMap<String, String> headers;

  private final String content;

  public Message(Map<String, String> headers, String content) {
    this.headers = new HashMap<String, String>(headers);
    this.content = content;
    this.headers.put(Header.CONTENT_LENGTH.name, String.valueOf(content == null
        ? 0
        : content.length()));
  }

  /**
   * Sends a message through the specified writer.
   *
   * @param writer to send the message through
   * @throws IOException
   */
  public void sendThrough(Writer writer) throws IOException {
    String content = maskNull(this.content);
    for (Map.Entry<String, String> entry : this.headers.entrySet()) {
      writeNonEmptyHeader(writer, entry.getKey(), entry.getValue());
    }
    writer.write(HEADER_TERMINATOR);
    if (content.length() > 0) {
      writer.write(content);
    }
    writer.flush();
  }

  /**
   * Reads a message from the specified reader.
   *
   * @param reader to read message from
   * @return a new message, or {@code null} if input is invalid (end-of-stream
   *         or bad message format)
   * @throws IOException
   * @throws MalformedMessageException if the input does not represent a valid
   *         message
   */
  public static Message fromBufferedReader(BufferedReader reader)
      throws IOException, MalformedMessageException {
    Map<String, String> headers = new HashMap<String, String>();
    synchronized (reader) {
      while (true) { // read headers
        String line = reader.readLine();
        if (line == null) {
          LOGGER.fine("End of stream");
          return null;
        }
        if (line.length() == 0) {
          break; // end of headers
        }
        String[] nameValue = line.split(":", 2);
        if (nameValue.length != 2) {
          LOGGER.log(Level.SEVERE, "Bad header line: {0}", line);
          return null;
        } else {
          String trimmedValue = nameValue[1].trim();
          headers.put(nameValue[0], trimmedValue);
        }
      }

      // Read payload if applicable
      String contentLengthStr = getHeader(headers, Header.CONTENT_LENGTH.name, "0");
      int contentLength = Integer.valueOf(contentLengthStr.trim());
      char[] content = new char[contentLength];
      int totalRead = 0;
      LOGGER.log(Level.FINER, "Reading payload: {0} bytes", contentLength);
      while (totalRead < contentLength) {
        int readBytes = reader.read(content, totalRead, contentLength - totalRead);
        if (readBytes == -1) {
          // End-of-stream (browser closed?)
          LOGGER.fine("End of stream while reading content");
          return null;
        }
        totalRead += readBytes;
      }

      // Construct response message
      String contentString = new String(content);
      return new Message(headers, contentString);
    }
  }

  /**
   * @return the "Tool" header value
   */
  public String getTool() {
    return getHeader(Header.TOOL.name, null);
  }

  /**
   * @return the "Destination" header value
   */
  public String getDestination() {
    return getHeader(Header.DESTINATION.name, null);
  }

  /**
   * @return the message content. Never {@code null} (for no content, returns an
   *         empty String)
   */
  public String getContent() {
    return content;
  }

  /**
   * @param name of the header
   * @param defaultValue to return if the header is not found in the message
   * @return the {@code name} header value or {@code defaultValue} if the header
   *         is not found in the message
   */
  public String getHeader(String name, String defaultValue) {
    return getHeader(this.headers, name, defaultValue);
  }

  private static String getHeader(Map<? extends String, String> headers, String headerName,
      String defaultValue) {
    String value = headers.get(headerName);
    if (value == null) {
      value = defaultValue;
    }
    return value;
  }

  private static String maskNull(String string) {
    return string == null
        ? ""
        : string;
  }

  private static void writeNonEmptyHeader(Writer writer, String headerName, String headerValue)
      throws IOException {
    if (headerValue != null) {
      writeHeader(writer, headerName, headerValue);
    }
  }

  @Override
  public String toString() {
    StringWriter sw = new StringWriter();
    try {
      this.sendThrough(sw);
    } catch (IOException e) {
      // never occurs
    }
    return sw.toString();
  }

  private static void writeHeader(Writer writer, String name, String value) throws IOException {
    writer.append(name).append(':').append(value).append(HEADER_TERMINATOR);
  }
}