package org.chromium.debug.core;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.sourcelookup.ISourceContainer;
import org.eclipse.debug.core.sourcelookup.ISourceContainerType;
import org.eclipse.debug.core.sourcelookup.ISourceContainerTypeDelegate;
import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
import org.eclipse.osgi.util.NLS;

/**
 * A special type of container that translates names of the source and delegates lookup
 * to another source container.
 * This could be useful when JS resource name is like "http://localhost/scripts/util.js"; such
 * source name could be converted into "scripts/util.js".
 * Currently container supports only prefix-based translation: if source name starts with a prefix,
 * the prefix is truncated; otherwise the source name is discarded.
 */
public class SourceNameMapperContainer implements ISourceContainer {

  private static final String TYPE_ID =
      "org.chromium.debug.core.SourceNameMapperContainer.type"; //$NON-NLS-1$

  private final ISourceContainer targetContainer;
  private final String prefix;

  public SourceNameMapperContainer(String prefix, ISourceContainer targetContainer) {
    this.targetContainer = targetContainer;
    this.prefix = prefix;
  }

  public void dispose() {
  }

  public String getPrefix() {
    return prefix;
  }

  public ISourceContainer getTargetContainer() {
    return targetContainer;
  }

  public Object[] findSourceElements(String name) throws CoreException {
    if (!name.startsWith(prefix)) {
      return new Object[0];
    }
    String shortName = name.substring(prefix.length());
    return targetContainer.findSourceElements(shortName);
  }


  public String getName() {
    return NLS.bind(Messages.SourceNameMapperContainer_NAME, prefix);
  }


  public ISourceContainer[] getSourceContainers() {
    return new ISourceContainer[] { targetContainer };
  }


  public ISourceContainerType getType() {
    return DebugPlugin.getDefault().getLaunchManager().getSourceContainerType(TYPE_ID);
  }


  public void init(ISourceLookupDirector director) {
  }


  public boolean isComposite() {
    return true;
  }

  private String getMemento() throws CoreException {
    StringBuilder builder = new StringBuilder();
    MementoFormat.encodeComponent(prefix, builder);
    MementoFormat.encodeComponent(targetContainer.getType().getId(), builder);
    MementoFormat.encodeComponent(targetContainer.getType().getMemento(targetContainer), builder);
    return builder.toString();
  }


  public Object getAdapter(Class adapter) {
    return null;
  }

  /**
   * A type delegate that serializes/deserializes container instances into/from memento.
   */
  public static class TypeDelegate implements ISourceContainerTypeDelegate {
    public ISourceContainer createSourceContainer(String memento) throws CoreException {
      MementoFormat.Parser parser = new MementoFormat.Parser(memento);
      String prefix;
      String typeId;
      String subContainerMemento;
      try {
        prefix = parser.nextComponent();
        typeId = parser.nextComponent();
        subContainerMemento = parser.nextComponent();
      } catch (MementoFormat.ParserException e) {
        throw new CoreException(new Status(IStatus.ERROR,
            ChromiumDebugPlugin.PLUGIN_ID, "Failed to parse memento", e)); //$NON-NLS-1$
      }
      ISourceContainerType subContainerType =
          DebugPlugin.getDefault().getLaunchManager().getSourceContainerType(typeId);
      ISourceContainer subContainer = subContainerType.createSourceContainer(subContainerMemento);
      return new SourceNameMapperContainer(prefix, subContainer);
    }

    public String getMemento(ISourceContainer container) throws CoreException {
      SourceNameMapperContainer chromeContainer = (SourceNameMapperContainer) container;
      return chromeContainer.getMemento();
    }
  }

  /**
   * Handles memento string format. The format is just a sequence of strings that are preceded
   * with their lengths and decorated with parentheses to make it more human-readable.
   */
  private static class MementoFormat {

    static void encodeComponent(String component, StringBuilder output) {
      output.append(component.length());
      output.append('(').append(component).append(')');
    }

    /**
     * A simple parser that reads char sequence as a sequence of strings.
     */
    static class Parser {
      private final CharSequence charSequence;
      private int pos = 0;
      Parser(CharSequence charSequence) {
        this.charSequence = charSequence;
      }
      String nextComponent() throws ParserException {
        if (pos >= charSequence.length()) {
          throw new ParserException("Unexpected end of line"); //$NON-NLS-1$
        }
        char ch = charSequence.charAt(pos);
        pos++;
        int num = Character.digit(ch, 10);
        if (num == -1) {
          throw new ParserException("Digit expected"); //$NON-NLS-1$
        }
        int len = num;
        while (true) {
          if (pos >= charSequence.length()) {
            throw new ParserException("Unexpected end of line"); //$NON-NLS-1$
          }
          ch = charSequence.charAt(pos);
          if (!Character.isDigit(ch)) {
            break;
          }
          pos++;
          num = Character.digit(ch, 10);
          if (num == -1) {
            throw new ParserException("Digit expected"); //$NON-NLS-1$
          }
          len = len * 10 + num;
        }
        pos++;
        if (pos + len + 1 > charSequence.length()) {
          throw new ParserException("Unexpected end of line"); //$NON-NLS-1$
        }
        String result = charSequence.subSequence(pos, pos + len).toString();
        pos += len + 1;
        return result;
      }
    }
    private static class ParserException extends Exception {
      ParserException() {
      }
      ParserException(String message, Throwable cause) {
        super(message, cause);
      }
      ParserException(String message) {
        super(message);
      }
      ParserException(Throwable cause) {
        super(cause);
      }
    }
  }
}