// Type annotation means that we are going to assign a specified type of value to that variable:
let firstName: string = "Cookie"
let age: number = 3
let hasWings: boolean = true
let evilness: null = null
let eyeColor: undefined = undefined
let hatchDate: Date = new Date(2018, 5, 28)

// If you try to reassign a different type of value to the same variable, you'll get a type error:
firstName = true // Error: Type 'boolean' is not assignable to type 'string'.

// Type annotations ending with square brackets denote the type is going to be an array filled with the specified type:
let colors: string[] = ["blue", "green"]
let luckyNumbers: number[] = [3, 12, 81]

// Or we can assign a type that we create ourselves:
class Parrot {...}
let parrotlet: Parrot = new Parrot()

// Object literal:
let coordinates: {latitude: number; longitude: number} = {
  latitude: 51.5,
  longitude: 0
}
coordinates[latitude] = true // Error: Type 'boolean' is not assignable to type 'number'.

const multiplier: (num1: number, num2: number) => number = (
  num1: number,
  num2: number
) => {
  return num1 * num2
}

// If we dissect this function, the first half following the variable name is the description of the function:
// Will take two arguments of type number and will return a number:
(num1: number, num2: number) => number

// And the rest is the function itself:
(num1: number, num2: number) => num1 * num2

// We can also write the same function like this:
const multiplier = (num1: number, num2: number) : number => num1 * num2

// If we dissect it, the part below specifies the type of arguments, and the return type, respectively:
// The part after the fat arrow is the function itself.
(num1: number, num2: number) : number

// Same style works with anonymous functions as well:
const divider = function(num1: number, num2: number): number{
  return num1 / num2
}

let fruitType = "peach"

console.log(typeof fruitType) // string
fruitType = true // Error: Type 'boolean' is not assignable to type 'string'.

// When we declare a variable but don't assign any values to it, the type is inferred as 'any'.
// Although we assign it a string on the second line, the type will not be inferred as 'string', but stay 'any'.
let fruitType
fruitType = "peach"

// If you want to declare and initialize in separate lines but don't want to give up on strict typing, you can do it like this:
let favoriteFruit: string
favoriteFruit = "strawberry"

favoriteFruit = true // Error: Type 'boolean' is not assignable to type 'string'.

// In the multiplier1 function, the return type is implicitly set to number.
// In the multiplier2 function, the return type is implicitly set to void, because we forgot the return keyword. If we have explicitly set the return type to number, the compiler would have warned us that this function wasn't returning anything.
const multiplier1 = (a: number, b: number) => {
  return a * b
}

const multiplier2 = (a: number, b: number) => {
  a * b
}

const multiplier3 = (a: number, b: number): number => {
  a * b // Error: A function whose declared type is neither 'void' nor 'any' must return a value.
}

let age: number | string = "Age not specified." // This states the 'age' variable is will either be a number or a string.
console.log(age) // Prints: "Age not specified."
age = 3
console.log(age) // Prints: 3
age = false // Error: Type 'boolean' is not assignable to type 'string | number'.

// In JS and TS, functions return undefined implicitly if no return statement is defined explicitly:
const errorLogger = (errorMessage: string): void => console.log(errorMessage)

const errorCreator = (a: number | string): never => {
  if (a < 0) throw new Error("The number cannot be lower than 0.")
  else if (a === 0) throw new Error("The number cannot be equal to 0.")
  else throw new Error("The number cannot be higher than 0.")
}

const pets = [
  {
    nickname: "Cookie",
    age: 3,
    message: "gimme almonds please",
    shout(message: string): void {
      console.log(this.message)
    },
  },
  {
    nickname: "Poof",
    age: 5,
    message: "oink oink oink",
    shout(message: string): void {
      console.log(this.message)
    },
  },
]

// Let's print the information given for each pet:
// When you don't destructure, you need to reach every property of the pet by using dot notation. (pet.something)
pets.map(
  (pet: {
    nickname: string
    age: number
    message: string
    shout: (msg: string) => void
  }) => {
    console.log(`${pet.nickname} is ${pet.age} years old.`)
    pet.shout(`${pet.message}!!!!`)
  }
)

// When you destructure, each property is their own variable and you can use them directly with their variable names:
pets.map(
  ({
    nickname,
    age,
    message,
    shout,
  }: {
    nickname: string
    age: number
    message: string
    shout: (msg: string) => void
  }) => {
    console.log(`${nickname} is ${age} years old.`)
    shout(`${message}!!!!`)
  }
)

// initializing a variable with an empty array and type annotation:
let cakeArr: string[] = []

// Type inference:
let teaArr = ["peach blossom", "raspberry", "blueberry", "hojicha", "genma cha"] // The inferred array type is: string[]
let randomArr = [3, "cat", new Date()] // The inferred array type is: (string | number | Date)[]
let arrOfArrs = [["hello"], "world"] // The inferred array type is: (string | string[])[]
let arrOfArrs = [["hello"]] // The inferred array type is: string[][]
let arrOfArrs = [["hello"], [3, 5, 6]] // The inferred array type is: (string[] | number[])[]

// Let's create a simple object:
const pet = {
  nickname: "Cookie",
  age: 3,
  isGreen: true,
}

// What if I wanted to represent the values of these properties inside of an array?
const pet1 = ["Cookie", 3, true]

// We can represent them inside the array, but as we lose the property names while doing that, keeping the order of things can help us understand what those values mean. So if I keep the order, I can create another pet just like this:
const pet2 = ["Dust", 7, false]

// A problem is, if you don't specify the type as a tuple, the TypeScript compiler thinks its an array. The tuple type annotation is slightly different from an array:
const pet3: [string, number, boolean] = ["Dander", 4, false]
pet2[0] = true
console.log(pet2) // Prints: [true, 7, false]
pet3[0] = true // Error: Type 'boolean' is not assignable to type 'string'.

// Let's create a type User:
type User = { name: string; age: number }

// Let's create some users of type User:
const u1: User = { name: "Maruchan", age: 30 }
const u2: User = { name: "Cake", age: 36 }

// Let's create a function to test how we're doing:
function isOlder({ name, age }: User, checkAge: number) {
  if (age > checkAge) return `Hi ${name}! Have a fun day!`
  else
    return `Hi ${name}! We are not accepting people under ${checkAge} at the moment. Please try again when you're older!`
}

console.log(isOlder(u1, 21)) // Prints: "Hi Maruchan! Have a fun day!"
console.log(isOlder(u2, 40)) // Prints: "Hi Cake! We are not accepting people under 40 at the moment. Please try again when you're older!"

const car = {
  manufacturer: "Subaru",
  year: 2019,
  isAvailable: true,
  label(): string {
    return `${this.manufacturer.slice(0, 2).toUpperCase()}${this.year}`
  },
}

const printInfo = (car: {
  manufacturer: string
  year: number
  isAvailable: boolean
  label(): string
}): void => {
  car.isAvailable
    ? console.log(
        `A ${car.year} model ${
          car.manufacturer
        } is available. Label: ${car.label()}`
      )
    : console.log(
        `The ${car.year} model ${
          car.manufacturer
        } is not available. Label: ${car.label()}`
      )
}

printInfo(car) // Prints: "A 2019 model Subaru is available."

interface Car {
  manufacturer: string
  year: number
  isAvailable: boolean
  label(): string
}

const car1 = {
  manufacturer: "Subaru",
  year: 2022,
  isAvailable: false,
  label(): string {
    return `${this.manufacturer.slice(0, 2).toUpperCase()}${this.year}`
  },
}

// Any object given as an argument to printInfo function has to satisfy the type specifications that Car interface has. If it doesn't, we'll receive an error. It doesn't check for extra properties, so as long as it satisfies the interface, we are good to go.
const printInfo = (car: Car): void => {
  car.isAvailable
    ? console.log(
        `A ${car.year} model ${
          car.manufacturer
        } is available. Label: ${car.label()}`
      )
    : console.log(
        `The ${car.year} model ${
          car.manufacturer
        } is not available. Label: ${car.label()}`
      )
}

printInfo(car1) // Prints: "The 2022 model Subaru is not available."

interface Product {
  isAvailable: boolean
  label(): string
}

const car = {
  manufacturer: "Subaru",
  year: 2022,
  isAvailable: false,
  label(): string {
    return `Car label: ${this.manufacturer.slice(0, 2).toUpperCase()}${
      this.year
    }`
  },
}

const fruit = {
  name: "Strawberry",
  expirationDate: new Date(),
  isAvailable: true,
  label(): string {
    return `Produce label: ${this.name
      .slice(0, 2)
      .toUpperCase()}${this.expirationDate.toString().slice(8, 10)}`
  },
}

const printInfo = (product: Product): void => {
  console.log(`${product.label()}, Available: ${product.isAvailable}`)
}

// Notice that both objects have a label function, but they are different functions.
printInfo(car) // Prints: "Car label: SU2022, Available: false"
printInfo(fruit) // Prints: "Produce label: ST06, Available: true"

type Pet = {
  // Let's make the name property optional:
  name?: string
  readonly age: number
}

let pet: Pet = { age: 3 } // No errors!
pet.age = 5 // Error: Cannot assign to 'age' because it is a read-only property.

// Let's try the same thing with an interface:
interface Cat {
  readonly name: string
  age?: number
}

let cat1: Cat = { age: 3 } // Error: Property 'name' is missing in type '{ age: number; }' but required in type 'Cat'.
let cat2: Cat = { name: "Carrot" } // No errors!
cat2.name = "Clemons" // Error: Cannot assign to 'name' because it is a read-only property.

// Can we combine interfaces to create a new type? Yes.
interface Mammal {
  whiskerCount: number
}

type Lion = Cat & Mammal // No errors
// Can we combine interfaces to create a new interface? No.
interface Lioness = Cat & Mammal // Errors: 'Cat' only refers to a type, but is being used as a value here. & 'Mammal' only refers to a type, but is being used as a value here.

// class names conventionally start with a capital letter:
class Beverage {
  drink(): void {
    console.log(`Chug chug chug...`)
  }
  slogan(): void {
    console.log(`Drinking soda makes life better!`)
  }
}

// classes can extend other classes and inherit all the properties and methods they have:
class CaffeinatedBeverage extends Beverage {
  // overriding the existing parent methods is also possible:
  slogan(): void {
    console.log("Caffeine: you know you need it anyway!")
  }
}

// As classes are only "blueprints" of objects, you must create instances of them before you can use their methods and properties:
const soda = new Beverage()
const coffee = new CaffeinatedBeverage()
coffee.slogan() // Prints: 'Caffeine: you know you need it anyway!'
coffee.drink() // Prints: 'Chug chug chug...'
soda.slogan() // Prints: 'Drinking soda makes life better!'
soda.drink() // Prints: 'Chug chug chug...'

abstract class GeometricShape {
  // An abstract class can have abstract properties and methods:
  name: string
  constructor(name: string) {
    this.name = name
  }

  abstract displayInfo(): string
  abstract calculateSurfaceArea(): number
  abstract calculateVolume(): number
}

class Cone extends GeometricShape {
  // A cone has an additional height and radius property:
  height: number
  radius: number
  constructor(name: string, radius: number, height: number) {
    // We need to call the parent class' constructor and give it the parameters it needs:
    super(name)
    this.height = height
    this.radius = radius
  }
  // We also need to define the abstract methods:
  displayInfo(): string {
    return `Name: ${this.name}, Shape: Cone, Radius: ${this.radius}, Height: ${
      this.height
    }, Surface Area: ${this.calculateSurfaceArea().toFixed(
      2
    )}, Volume: ${this.calculateVolume().toFixed(2)}`
  }

  calculateSurfaceArea(): number {
    return (
      Math.PI *
      this.radius *
      (this.radius + Math.sqrt(this.height ** 2 + this.radius ** 2))
    )
  }
  calculateVolume(): number {
    return (Math.PI * this.radius ** 2 * this.height) / 3
  }
}

const cone1 = new Cone("Cone1", 3, 4)
console.log(cone1.displayInfo()) // Prints: "Name: Cone1, Shape: Cone, Radius: 3, Height: 4, Surface Area: 75.40, Volume: 37.70"

class Sphere {
  // Static and non-static properties can exist with the same name because they will be accessed in different ways:
  static pi: number = 3.14
  public pi: number = 3

  static calculateVolume(radius: number): number {
    return (4 / 3) * (this.pi * radius ** 3)
  }
  static calculateSurfaceArea(radius: number): number {
    return 4 * this.pi * radius ** 2
  }

  public calculateDiameter(radius: number): number {
    return 2 * radius
  }
}

// Now we can call the static methods and properties without creating an instance of the Sphere class:
console.log(Sphere.pi) // Prints: 3.14
console.log(Sphere.calculateVolume(2)) // Prints: 33.49333333333333
console.log(Sphere.calculateSurfaceArea(2)) // Prints: 50.24
console.log(Sphere.calculateDiameter(2)) // Error: Property 'calculateDiameter' does not exist on type 'typeof Sphere'.

// What happens when we create an instance of it?
const globe = new Sphere()
console.log(globe.pi) // Prints: 3
console.log(globe.calculateVolume(2)) // Error: Property 'calculateVolume' does not exist on type 'Sphere'. Did you mean to access the static member 'Sphere.calculateVolume' instead?
console.log(globe.calculateSurfaceArea(2)) // Error: Property 'calculateSurfaceArea' does not exist on type 'Sphere'. Did you mean to access the static member 'Sphere.calculateSurfaceArea' instead?
console.log(globe.calculateDiameter(2)) // Prints: 4

// Let's implement a stack data structure for arrays of strings:
class StackStr {
  private stack: string[]
  constructor(arr: string[]) {
    this.stack = arr
  }
  public push(item: string): string[] {
    return this.stack.push(item)
  }
  public pop(): string {
    return this.stack.pop()
  }
  public printStack(): void {
    console.log(this.stack)
  }
}

const stack1 = new StackStr(["1", "2", "3"])
const stack2 = new StackStr([1]) // Error: Type 'number' is not assignable to type 'string'.
const stack3 = new StackStr([])
stack1.printStack() // Prints: ["1", "2", "3"]
console.log(stack1.pop()) // Prints: "3"
stack1.printStack() // Prints: ["1", "2"]
console.log(stack1.push("hai")) // Prints: ["1", "2", "hai"]

class Stack<T> {
  private stack: T[]
  constructor(arr: T[]) {
    this.stack = arr
  }
  public push(item: T): T[] {
    return this.stack.push(item)
  }
  public pop(): T {
    return this.stack.pop()
  }
  public printStack(): void {
    console.log(this.stack)
  }
}

const stack1 = new Stack<string>(["1", "2", "3"])
const stack2 = new Stack<number>([11, 22, 33])
const stack3 = new Stack<boolean>([true, false, true, true, true])
const stack4 = new Stack<string>(["1", 22]) // Error: Type 'number' is not assignable to type 'string'.
stack1.printStack() // Prints: ["1", "2", "3"]
stack2.printStack() // Prints: [11, 22, 33]
stack3.printStack() // Prints: [true, false, true, true, true]
console.log(stack1.pop()) // Prints: "3"
console.log(stack2.pop()) // Prints: 33
console.log(stack3.pop()) // Prints: true
stack1.printStack() // Prints: ["1", "2"]
stack2.printStack() // Prints: [11, 22]
stack3.printStack() // Prints: [true, false, true, true]
console.log(stack1.push("hai")) // Prints: ["1", "2", "hai"]
console.log(stack2.push("hai")) // Error: Argument of type 'string' is not assignable to parameter of type 'number'.
console.log(stack3.push(false)) // Prints: [true, false, true, true, false]

function displayInfo<T, U>(
  name: T,
  age: U,
  occupation: T,
  hobbies: string[]
): void {
  const lastHobby: string | undefined = hobbies.length ? hobbies.pop() : ""
  hobbies.length
    ? console.log(
        `${name}, the ${age} year old ${occupation}, likes ${hobbies.join(
          ", "
        )}, and ${lastHobby} in her free time.`
      )
    : console.log(`${name} is a ${age} year old ${occupation}.`)
}

displayInfo<string, number>("Irene", 29, "medical researcher", [
  "fishing",
  "painting",
  "singing",
]) // Prints: "Irene, the 29 year old medical researcher, likes fishing, painting, and singing in her free time."

displayInfo<string, string>(
  "Jamie",
  "never-ask-a-lady-her-age",
  "fashion designer",
  ["running", "baking", "gardening"]
) // Prints: "Jamie, the never-ask-a-lady-her-age year old fashion designer, likes running, baking, and gardening in her free time."

interface ProductInfo<T, U> {
  productName: T
  id: U
  createLabel(productName: T, id: U): T
}

let strawberry: ProductInfo<string, number> = {
  productName: "strawberry",
  id: 123456789,
  createLabel(arg1, arg2) {
    return `${arg1}${arg2}`
  },
}

let couch: ProductInfo<string, string> = {
  productName: "couch",
  id: "987654321",
  createLabel(arg1, arg2) {
    return `${arg2}${arg1}`
  },
}

console.log(strawberry.createLabel(strawberry.productName, strawberry.id)) // Prints: "strawberry123456789"
console.log(couch.createLabel(couch.productName, couch.id)) // Prints: "987654321couch"

type Pet = { name: string; age: number; isEvil: boolean }

type PartialBird = Partial<Pet> // This is the same as: type PartialBird = {name?: string, age?: number, isEvil?: boolean }
type RequiredBird = Required<Pet> // This is the same as: type RequiredBird = {name: string, age: number, isEvil: boolean }
type ReadonlyBird = Readonly<Pet> // This is the same as: type ReadonlyBird = {readonly name: string, readonly age: number, readonly isEvil: boolean }
type PickedBird = Pick<Pet, "name" | "isEvil"> // This is the same as: type PickedBird = {name: string, isEvil: boolean }

type User = {
  id: string
  username: string
  luckyNumber: number
}

type Admin = {
  services: User
  website: User
  internal: User
}

// The Admin type could be written like this as well:
type Admin = Record<"services" | "website" | "internal", User>

// We decided we don't care about users lucky numbers:
type modifiedUser = Omit<User, "luckyNumber"> // This is the same as: type modifiedUser = {id: string; username: string}

namespace StringUtilities {
  // Unless you export them you won't be able to use them elsewhere:
  export function capitalize(str: string): string {
    return str.slice(0, 1).toUpperCase() + str.slice(1)
  }

  export function selectRandomLetterFromString(str: string): string {
    let randomNum = Math.floor(Math.random() * str.length)
    return str.toLowerCase().split(" ").join("")[randomNum]
  }
}

// you can use object literal notation when you're calling:
console.log(StringUtilities.capitalize("hello world")) // Prints: "Hello world"
console.log(
  StringUtilities.selectRandomLetterFromString("why does it always rain on me")
) // Prints random letter