// 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.debug.core.model;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;

import org.chromium.sdk.Breakpoint;
import org.chromium.sdk.Script;

/**
 * A registry of existing breakpoints associated with their script locations. It
 * is used to restore
 */
public class BreakpointRegistry {

  /**
   * Script identifier for a breakpoint location.
   */
  public static class ScriptIdentifier {
    private final String name;

    private final long id;

    private final int startLine;

    private final int endLine;

    public static ScriptIdentifier forScript(Script script) {
      String name = script.getName();
      return new ScriptIdentifier(
          name,
          name != null ? -1 : script.getId(),
          script.getStartLine(),
          script.getEndLine());
    }

    private ScriptIdentifier(String name, long id, int startLine, int endLine) {
      this.name = name;
      this.id = id;
      this.startLine = startLine;
      this.endLine = endLine;
    }

    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + (int) (id ^ (id >>> 32));
      result = prime * result + ((name == null) ? 0 : name.hashCode());
      result = prime * result + 17 * startLine + 19 * endLine;
      return result;
    }

    @Override
    public boolean equals(Object obj) {
      if (!(obj instanceof ScriptIdentifier)) {
        return false;
      }
      ScriptIdentifier that = (ScriptIdentifier) obj;
      if (this.startLine != that.startLine || this.endLine != that.endLine) {
        return false;
      }
      if (name == null) {
        // an unnamed script, only id is known
        return that.name == null && this.id == that.id;
      }
      // a named script
      return this.name.equals(that.name);
    }
  }

  static class BreakpointLocation {
    private final ScriptIdentifier scriptIdentifier;

    private final int line;

    public BreakpointLocation(ScriptIdentifier scriptIdentifier, int line) {
      this.scriptIdentifier = scriptIdentifier;
      this.line = line;
    }

    public ScriptIdentifier getScriptIdentifier() {
      return scriptIdentifier;
    }

    public int getLine() {
      return line;
    }

    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + line;
      result = prime * result + ((scriptIdentifier == null)
          ? 0
          : scriptIdentifier.hashCode());
      return result;
    }

    @Override
    public boolean equals(Object obj) {
      if (!(obj instanceof BreakpointLocation)) {
        return false;
      }
      BreakpointLocation that = (BreakpointLocation) obj;
      return (this.line == that.line && eq(this.scriptIdentifier, that.scriptIdentifier));
    }
  }

  /**
   * A breakpoint accompanied by its line number in the corresponding enclosing
   * resource.
   */
  public static class BreakpointEntry {
    public final Breakpoint breakpoint;

    public final int line;

    private BreakpointEntry(Breakpoint breakpoint, int line) {
      this.breakpoint = breakpoint;
      this.line = line;
    }

    boolean isWithinScriptRange(Script script) {
      return line >= script.getStartLine() && line <= script.getEndLine();
    }

    @Override
    public int hashCode() {
      return 31 * line + 17 * breakpoint.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
      if (!(obj instanceof BreakpointEntry)) {
        return false;
      }
      BreakpointEntry that = (BreakpointEntry) obj;
      return this.line == that.line && this.breakpoint.equals(that.breakpoint);
    }
  }

  private final Map<ScriptIdentifier, Collection<BreakpointEntry>> scriptIdToBreakpointEntries =
      new HashMap<ScriptIdentifier, Collection<BreakpointEntry>>();

  /**
   * Adds the given line breakpoint.
   *
   * @param script where the breakpoint is set
   * @param line (0-based, like in V8) in the script
   * @param breakpoint
   */
  public void add(Script script, int line, Breakpoint breakpoint) {
    ScriptIdentifier scriptId = ScriptIdentifier.forScript(script);
    Collection<BreakpointEntry> entries = scriptIdToBreakpointEntries.get(scriptId);
    if (entries == null) {
      entries = new HashSet<BreakpointEntry>();
      scriptIdToBreakpointEntries.put(scriptId, entries);
    }
    entries.add(new BreakpointEntry(breakpoint, line));
  }

  /**
   * Gets breakpoint entries for the given script. An empty collection for a
   * {@code null} script.
   *
   * @param script to extract the breakpoints for
   * @return the breakpoints that fall within the given script line range
   */
  public Collection<? extends BreakpointEntry> getBreakpointEntries(Script script) {
    if (script == null) {
      return Collections.emptySet();
    }
    Collection<BreakpointEntry> entries =
        scriptIdToBreakpointEntries.get(ScriptIdentifier.forScript(script));
    if (entries == null) {
      return Collections.emptySet();
    }
    Collection<BreakpointEntry> scriptBreakpoints = new LinkedList<BreakpointEntry>();
    // Linear search should work fairly well for a reasonable number of
    // breakpoints per script
    for (BreakpointEntry entry : entries) {
      if (entry.isWithinScriptRange(script)) {
        scriptBreakpoints.add(entry);
      }
    }
    return scriptBreakpoints;
  }

  /**
   * Removes the given line breakpoint in the given script. Does nothing for a
   * {@code null} script (which may be the case after a navigation + disconnect
   * when the resource referenced by the breakpoint marker is absent.)
   *
   * @param script where the breakpoint is set
   * @param line (0-based, like in V8) in the script
   * @param breakpoint
   */
  public void remove(Script script, int line, Breakpoint breakpoint) {
    if (script == null) {
      return;
    }
    ScriptIdentifier scriptId = ScriptIdentifier.forScript(script);
    Collection<BreakpointEntry> entries = scriptIdToBreakpointEntries.get(scriptId);
    if (entries == null) {
      return;
    }
    if (entries.size() == 1) {
      scriptIdToBreakpointEntries.remove(scriptId);
    } else {
      entries.remove(new BreakpointEntry(breakpoint, line));
    }
  }

  protected static boolean eq(Object left, Object right) {
    return left == right || (left != null && left.equals(right));
  }

}