package algs34;

import java.util.*;
import stdlib.*;

/*
 * Complete the methods of MyFB so that it works.
 * Each method must work in the worst case time given below (assuming uniform hashing and ignoring string lengths):
 *
 *   addPerson must take constant time
 *
 *   addFriendship must take constant time
 *
 *   queryFriendship must take constant time
 *
 *   removeFriendship should take constant time
 *
 *   lookupFriends should take time proportional to the number of
 *   friends that the named person has (or less)
 *
 * Your solution should use a single field of type
 *
 *   HashMap<Person,HashSet<Person>>
 *
 * You will need to add hashCode and equals methods to the Person class.
 * Follow the suggestions from Joshua Bloch, given in items 7 and 8 here:
 *
 *   http://fpl.cs.depaul.edu/jriely/ds2/extras/Chapter3.pdf
 *
 * Don't change the first line of any method given below.
 * The names and types of the methods should not change.
 * I will run you MyFB class using my own main method.
 *
 * You can add more classes too.  Just put them all in this file, inside MyFB.
 * Any classes you add should be "static" and not "public".
 * You can import/use any file in the java APIs.
 * You can import/use any file in the algs packages.
 *
 * You do not need to implement a hash table for this assignment.
 * You can use java.util.HashMap, java.util.HashSet, or the implementations in algs34.
 *
 * You do not need to implement a iterable object.
 * You can use algs13.Queue.
 * Also note that all of the Map implementations we have looked at create an iterable
 *   object via the keys() method.
 *
 *
 * Here is an example session:
 *
 *   INPUT           OUTPUT
 *
 *   p sa 8
 *   p li 7
 *   p he 9
 *   p tu 5
 *   f li 7 tu 5
 *   f li 7 he 9
 *   f tu 5 sa 8
 *   l tu 5          li 7 sa 8
 *   l sa 8          tu 5
 *   u li 7 tu 5
 *   l tu 5          sa 8
 *   q li 7 he 9     yes
 *   q he 9 li 7     yes
 *   q he 9 li 23    no
 *   q he 9 he 9     no
 *
 * Note that friendship is symmetric and irreflexive.
 * So if a/b are friends, then so are b/a.
 * And no one is their own friend.
 *
 * Put the following in a file "input.txt" to run this test:
p sa 8
p li 7
p he 9
p tu 5
f li 7 tu 5
f li 7 he 9
f tu 5 sa 8
l tu 5
l sa 8
u li 7 tu 5
l tu 5
q li 7 he 9
q he 9 li 7
q he 9 li 23
q he 9 he 9
 */
public class MyFB {
  public static boolean DEBUG = true;
  public static Person makePerson (In in) {
    try {
      String name = in.readString ();
      int age = in.readInt ();
      return makePerson (name, age);
    } catch (java.util.InputMismatchException e) {
      StdOut.println ("Input format error");
      return null;
    }
  }
  public static Person makePerson (String name, int age) {
    return new Person (name, age);
  }
  static class Person {
    String name;
    int age;
    public Person (String name, int age) {
      this.name = name;
      this.age = age;
    }
    public String toString () {
      return name + " " + age;
    }
    @Override
    public boolean equals (Object obj) {
      return true;
    }
    @Override
    public int hashCode () {
      return 1293879128;
    }
    
  }
  public static void main (String[] args) {
    Trace.showBuiltInObjects (true);
    //Trace.run ();
    Person x = makePerson ("xi", 1);
    Person y = makePerson ("xi", 1);
    StdOut.println (x.hashCode());
    StdOut.println (y.hashCode());
  }
  
  HashMap<Person,HashSet<Person>> map = new HashMap<>();

  // a person "exists" after they are added using addPerson
  // addPerson does nothing if p already exists
  public void addPerson (Person p) {
    // TODO
    if (DEBUG) { StdOut.format ("P %s: %s\n", p, map); }
  }
  // addFriendship does nothing if p1 and p2 are already friends or if one does not exist
  public void addFriendship (Person p1, Person p2) {
    // TODO
    if (DEBUG) { StdOut.format ("F %s %s: %s\n", p1, p2, map); }
  }
  // removeFriendship does nothing if p1 and p2 are not friends or if one does not exist
  public void removeFriendship (Person p1, Person p2) {
    // TODO
    if (DEBUG) { StdOut.format ("U %s %s: %s\n", p1, p2, map); }
  }
  // queryFriendship returns false if p1 and p2 are not friends or if one does not exist
  public boolean queryFriendship (Person p1, Person p2) {
    if (DEBUG) { StdOut.format ("Q %s %s: ", p1, p2); }
    // TODO
    return false;
  }
  // lookupFriends returns null or empty iterable if p does not exists
  public Iterable<Person> lookupFriends (Person p) {
    if (DEBUG) { StdOut.format ("L %s:", p); }
    // TODO
    return null;
  }

  public static void main2 (String[] args) {
    Trace.showBuiltInObjects (true);
    //Trace.run ();
    /*
     * The first line below causes "in" to read from the console. You can
     * change this to read from a file, by using something like the line
     * below, where "input.txt" is a file you create in your eclipse
     * workspace. The file should be in the same folder that contains "src"
     * "bin" and "lib":
     */

    //In[] inputFiles = new In[] { new In () }; // from console
    //In[] inputFiles = new In[] { new In ("input.txt") }; // from file
    In[] inputFiles = new In[] { new In ("input.txt"), new In () }; // from file, then console
    MyFB fb = new MyFB ();
    StdOut.println ("Enter one of the following:");
    StdOut.println ("  P name age -- add person");
    StdOut.println ("  F name1 age1 name2 age2 -- add friendship");
    StdOut.println ("  U name1 age1 name2 age2 -- remove friendship");
    StdOut.println ("  Q name1 age1 name2 age2 -- query friendship");
    StdOut.println ("  L name age -- lookup friends");
    StdOut.println ("  R -- restart");
    StdOut.println ("  X -- exit");
    for (In in : inputFiles) {
      while (in.hasNextLine ()) {
        //StdOut.println (fb. ...); // while debugging, print debugging info here!  You can print maps, sets, lists.
        String action;
        try {
          action = in.readString ();
        } catch (NoSuchElementException e) { continue; }
        switch (action) {
        case "P":
        case "p": {
          Person p = makePerson (in);
          fb.addPerson (p);
          break;
        }
        case "F":
        case "f": {
          Person p1 = makePerson (in);
          Person p2 = makePerson (in);
          fb.addFriendship (p1, p2);
          break;
        }
        case "U":
        case "u": {
          Person p1 = makePerson (in);
          Person p2 = makePerson (in);
          fb.removeFriendship (p1, p2);
          //Trace.draw ();
          break;
        }
        case "Q":
        case "q": {
          Person p1 = makePerson (in);
          Person p2 = makePerson (in);
          boolean result = fb.queryFriendship (p1, p2);
          StdOut.println (result ? "Yes" : "No");
          break;
        }
        case "L":
        case "l": {
          Person p = makePerson (in);
          Iterable<Person> result = fb.lookupFriends (p);
          if (result != null) {
            for (Person friend : result) {
              StdOut.print (friend);
              StdOut.print (" ");
            }
          }
          StdOut.println ();
          break;
        }
        case "R":
        case "r":
          fb = new MyFB ();
          break;
        case "X":
        case "x":
          System.exit (0);
        }
      }
    }
  }
}