/**
 * ✅ This is a multiline comment
 * so you can write a very long comment.
 * This format is used to document your code.
 */

/* ✅
This is a valid  multiline
comment
*/

/* ✅ as well as this one*/

// ✅ This is an inline comment. You can't use multiline
because this line won't be interpreted as a comment ❌

// ✅ method execution ends until the semi-colon appears
sendAnEmail("hey@well.com");

// ✅ declaration ends until the semi-colon appears
String thisWillStoreMyDogName = "Pulgas";

/**
 * ❌ In this line I forget to write a semicolon after "Florencio"
 * so the Java compiler will understand that these two lines are the same
 * instruction, so the instruction:
 *  
 * String myFishName = "Florencio"String myDogAge = 4;
 *
 * doesn't make sense to the compiler and will be marked
 * as an error
 */
String myFishName = "Florencio"
String myDogAge = 4;

public String sendAnEmail(String email) {
  // ✅ return statement ends until semi-colon appears
  return "Message sent to: " + email;
}

public String sendAnSMS(String phone) {
  // ❌ Java will read the sentence as:
  // return "Message sent to: " + phone }
  // so it doesn't make sense to the compiler
  // if a curly brace } appears at the end of a return
  // statement. So don't forget the semicolons never!
  return "Message sent to: " + phone
}

public class Cellphone { // your class scope starts here

  // ✅ These variable will be available for all the methods 
  // inside the class curly braces {}
  public String myCatName = "Bigotes";


  public String getCatName() { // method scope starts here
    // ✅ You can access to the variable at class level from the 
    // method using the special word `this` only if the
    // method is under the class scope defined by the class 
    // curly braces
    return this.myCatName;
  } //  method scope ends here


  public String getDogName() { // method scope starts here
    // ✅ You can access to the variables inside the {} of the method
    String myDogName = "Pulgas";
    return myDogName;
  } // method scope ends here


  public String getMyDogName() { // method scope starts here
    // ❌ This method will cause an error because it doesn't know 
    // about the variables of other methods that are out of
    // its scope
    return myDocName;
  } // method scope ends here


} // class scope ends here

int myNum = 5;             // Integer (whole number)
float myFloatNum = 5.99f;  // Floating point number
char myLetter = 'A';       // Character
boolean myBool = true;     // Boolean
String myText = "A text";  // String

public class MyPublicClass {
  // This variable is accesible inside the class  only.
  private myDogName = "Pulgas";

  // This method is accesible from the outside of the class and package
  public void getFirstLetterOfMyDogName() {
    String letter = this.myDogName.substring(string.length() - 1);
    return formatText(letter);
  }

  /**
   * This method is for internal usage in the class only.
   * We don't want others to know what we are doing here.
   */
  private String formatText(String text) {
    return "Your dog's name first letter is: " + text.toUpperCase();
  }

  /**
   * This method is accessible at package level
   * or available to sub-classes
   */
  protected void sayHello() {
    System.out.println("No, I will say goodbye!");
  }

  /**
   * This method has a default access modifier, so
   * it will be available at package level only,
   * and for subclasses inside the package.
   */
  void sayHello() {
    System.out.println("Goodbye!");
  }
}

// First of all, lets create an object based on the MyPublicClass
MyPublicClass objectInstance = new MyPublicClass();

// ✅ Now that the object exists, lets execute this public method
objectInstance.getFirstLetterOfMyDogName();
// It works fine because the method is public, so we can access from the outside

// ❌ But this method execution is not possible because the method
// is privated and it's not available for external usage
objectInstance.formatText();

// ❌ Trying to access to a private class variable isn't possible either
objectInstance.myDogName;

// ✅ Declare a variable without an initial value.
// You can't use it until you set it a value
int age;

// ✅ You can declare many variables in a single line
// if all them are of the same type
String address, email, website;

// ✅ You can set a value to the variable in this way
age = 25; // the "=" is called assignation operator

// ✅ Declare a variable with an initial value
String name = "unknown user";

// ✅ You can set a new value later
name = "Sara";

// You must set compatible types
// ✅ This is valid
boolean isAnAdult = true;

// ❌ But this is not valid because "nop" is a String
// and isAnAdult was declared as a boolean type variable
isAnAdult = "nop";

// ✅ Class level variables are declared in this way
public String myName = "Unknown";
private String myDog = "Pulgas";
protected String myCat = "Bigotes";

[access modifier] [return value type] [methodName]([args]) {
  ...method definition
}

public void doNothing() {
 // ✅ nothing will happens when you execute this method
}

// ✅ This method don't return anything so we declare it as void
// Also, this method doesn't receive any arg, so we keep the () empty
public void saySomethingNice() {
 // your instructions go here..
 System.out.println("Hi there! You are a nice person!");
}

/**
 * ✅ This method will return a text with the planet name
 * so we specify String as the return type.
 * Also, this method doesn't receive any arg, so we keep the () empty
 */
public String giveMeThePlanetName() {
  return "Earth";
}

/**
 * ❌ This method will throw an error because the method
 * return type is specified as void, so the Java compiler
 * won't allow to return anything, but you are trying to
 * return something
 */
public void giveMeTheCountryName() {
  return "I don't know";
}

/**
 * ✅ This method will return a number with the result of a sum
 * so we specify int as the return type.
 * Also, this method receives two args, both int numbers
 */
public int sumTwoNumbers(int numberA, int numberB) {
  int result = numberA + numberB;
  return result;
}

/**
 * ❌ This method will throw an error because the method
 * return type is specified as int, so the Java compiler
 * expects a compatible return value, but you are not returning anything
 */
public int giveMeThisPostYear() {

}

/**
 * ✅ You can combine methods
 */
public void sum1and3() {
  const myResult = sumTwoNumbers(1, 2);
   // System.out.println method writes a text in the console
   // you can see a running example in the Classes section
   System.out.println("This is the result: " + myResult);
}

// ✅ This is the common way to use the if-else statements
if (true) {
  // the condition was fullfilled
} else {
  // the condition specified in the if was not fullfilled
}

// ❌ You can't use only the else statement alone because it depends on the if statement defined rules
else {

}

// ✅ But you can use only the if
if ((2 + 2) == 4) {
  System.out.println("Mathematics are right");
}

// ✅ You can omit the curly braces {} if you only have one line per statement
if (1 < 8)
  System.out.println("1 is less than 8");
else
  System.out.println("1 is not less than 8, it could be equals or bigger");


/**
 * ❌ Java compiler will detect an error here because se second System.out,println
 * is not part of the if statement and then it finds the else statement after something that is not
 * an if statement
 */
if (1 < 8)
  System.out.println("1 is less than 8");
  System.out.println("isn't ok?");
else
  System.out.println("1 is not less than 8, it could be equals or bigger");

// ✅ You can fix it in this way
if (1 < 8) {
  System.out.println("1 is less than 8");
  System.out.println("isn't ok?");
}
else
  System.out.println("1 is not less than 8, it could be equals or bigger");

// The first step is to declare our blueprint (our class).
// In Java, all the classes name must be in PascalCase, the first letter must be capital
public class Bot {

}

public class Bot {
  /**
   * These variables are private because are for internal usage
   * we don't want and don't need to make them accesible.
   * Remember to expose just the very needed and useful data
   * and functionalities.
   */
  private String botName; // can store a single string: "Mr Bot"
  private ArrayList<String> proposedPlaces = new ArrayList<String>(); // can store a group of texts: ["Beerhole", "Sam's Bar and Wine", "Super Taco"]
  private String dayOfWeek; // can store a single string: "Friday"
  private String hour; // can store a single string: "5:00pm"

}

Bot ourSuperBot = new Bot();
Bot superBotBrother = new Bot();
Bot kevinBot = new Bot();

public class Bot {
  private String botName;
  private ArrayList<String> proposedPlaces = new ArrayList<String>();
  private String dayOfWeek;
  private String hour;

  // This is the constructor. The constructor must have the
  // class name and must be public. Also, it has not a return type 
  public Bot(String botName, String dayOfWeek, String hour) {
    // the word "this" allows you to access to variables at class level
    this.botName = botName;
    this.dayOfWeek = dayOfWeek;
    this.hour = hour;
  }

}

public class Bot {
  private String botName;
  private ArrayList<String> proposedPlaces = new ArrayList<String>();
  private String dayOfWeek;
  private String hour;
}

 public Bot(String botName, String dayOfWeek, String hour) {
    this.botName = botName;
    this.dayOfWeek = dayOfWeek;
    this.hour = hour;
  }

  // Must be public to allow to use it when the object 
  // instance is created. We don't need to return any value
  // so we declare it as void. We need to receive the place
  // as an string, and save it in the global variable
  public void proposeAPlace(String place) {
    // the add() method allows to add an item at the end of the list
    this.proposedPlaces.add(place);
  }

public class Bot {
  private String botName;
  private ArrayList<String> proposedPlaces = new ArrayList<String>();
  private String dayOfWeek;
  private String hour;

 public Bot(String botName, String dayOfWeek, String hour) {
    this.botName = botName;
    this.dayOfWeek = dayOfWeek;
    this.hour = hour;
  }

  public void proposeAPlace(String place) {
    this.proposedPlaces.add(place);
  }

  /**
   * We need to return a string (the randomly choosed place)
   * so we declare the method return type as String.
   * We don't need to receive anything so we don't specify 
   * anything in the params. And that's all.
   */
  public String chooseAPlace() {
    Random rand = new Random(); // this is an special object of Java to make random things
    return this.proposedPlaces.get(rand.nextInt(proposedPlaces.size()));
  }

public class Bot {

  ... // this means that there are more code above but we don't want to write it again in this piece of example code

  private String decorateText(String textToDecorate){
    String decoratedText = "The winner this week is: " + textToDecorate;
    return decoratedText;
  }

public class Bot {
  private String botName;
  private ArrayList<String> proposedPlaces = new ArrayList<String>();
  private String dayOfWeek;
  private String hour;

  public Bot(String botName, String dayOfWeek, String hour) {
    this.botName = botName;
    this.dayOfWeek = dayOfWeek;
    this.hour = hour;
  }

  public void proposeAPlace(String place) {
    this.proposedPlaces.add(place);
  }

  /**
   * We need to update our method to implement the new
   * decorateText method in order to decorate the text before 
   * returning the choosed place;
   */
  public String chooseAPlace() {
    Random rand = new Random();

    /**
     * All the proposed places are stored in proposedPlaces
     * global variable.
     * proposedPlaces is a list of elements, each element has 
     * a number that defines its position (0, 1, 2, 3) 
     * starting from 0.
     * To select a place from the list, we need to specify 
     * its position number.
     * To randomly select a number, we will use the "rand" 
     * object instance to access to a method called 
     * "nextInt()".
     * We need to tell the "nextInt()" what is the maximum 
     * number of options (if you set 4, the method will 
     * choose a number between 0 and 4).
     * The maximum number of options is the number of items
     * in our proposedPlaces list.
     * To get the number of items in proposedPlaces, we use
     * the size() method which returns an Integer number with
     * the count of items in the list.
     */
    int countOfPlaces = proposedPlaces.size();
    int randomPlacePosition = rand.nextInt(countOfPlaces);


    String choosedPlace = this
                          .proposedPlaces
                          .get(randomPlacePosition);

    String decoratedText = decoratedText(choosedPlace);

    return decoratedText;
  }

  private String decorateText(String textToDecorate){
    String decoratedText = "Hi! This is " + this.botName + ". The winner this week is: " + textToDecorate + ". Schedule this date to meet your friends: " + this.dayOfWeek + " " + this.hour;

    return decoratedText;
  }
}

// ✅ Create a bot instance and configure it
// Remember that the args we are passing through will be received by the constructor method
Bot ourSuperBot = new Bot("Mr Bot", "friday", "5:20pm");

// ✅ Execute the proposeAPlace method as many times you need
ourSuperBot.proposeAPlace("Beerhole"); // Peter propose "Beerhole"
ourSuperBot.proposeAPlace("Sam's Bar and Wine"); // Sara propose "Sam's Bar and Wine"
ourSuperBot.proposeAPlace("Super Taco"); // and you propose "Super Taco"

// ✅ Finally, we ask the ourSuperBot object to randomly choose 
// a place and store it in a new String type variable.
String choosedPlace = ourSuperBot.chooseAPlace();

// ❌ Will throw an error because decorateText is for internal class usage only (private)
ourSuperBot.decorateText("Empanadas Juanita");

// ❌ Will throw an error because proposedPlaces is for internal class usage only (private)
ourSuperBot.proposedPlaces;