#include <iostream>
#include <string>
using namespace std;

class Product {
private:
  string name;
  double price;
public:
  void init(string n, double p) {
    name = n;
    price = (p >= 0) ? p : 0;
  }
  void display() const {
    cout << name << " - " << price << " VND" << endl;
  }
};

int main() {
  Product item1;
  item1.init("Mechanical Keyboard", 1200000);
  item1.display(); // dot operator
  // item1.price = -500; // COMPILE ERROR!
  return 0;
}

class BankAccount {
private:
  string accountNumber;
  double balance;
public:
  BankAccount(string id, double init) {
    accountNumber = id;
    balance = (init >= 0) ? init : 0;
  }
  // Getter: Read-only access
  double getBalance() const { return balance; }

  // Setter with business rule enforcement
  bool deposit(double amount) {
    if (amount <= 0) return false;
    balance += amount;
    return true;
  }
  bool withdraw(double amount) {
    if (amount <= 0 || amount > balance) return false;
    balance -= amount;
    return true;
  }
};

class Transaction;

class Account {
private:
  double balance;
  string pinCode;
  friend class Transaction; // Grant full access
public:
  Account(double b, string pin)
    : balance(b), pinCode(pin) {}
};

class Transaction {
public:
  bool transfer(Account& from, Account& to,
                double amount, string pin) {
    if (from.pinCode != pin) return false; // private!
    if (from.balance < amount) return false;
    from.balance -= amount; // private!
    to.balance += amount;
    return true;
  }
};

class Product {
private:
  string name;
  double price;
public:
  Product(string n, double p) : name(n), price(p) {}
  void display() const {
    cout << name << ": " << price << " VND" << endl;
  }
};

int main() {
  // 1. Pointer to STACK object
  Product p1("Mouse", 250000);
  Product* ptr1 = &p1;
  ptr1->display(); // Arrow operator

  // 2. Dynamic HEAP object
  Product* ptr2 = new Product("Monitor 27-inch", 4500000);
  ptr2->display();

  delete ptr2;  // Mandatory cleanup!
  ptr2 = nullptr;
  return 0;
}

class Employee {
private:
  int id;
  string name;
public:
  Employee() : id(0), name("N/A") {} // REQUIRED!
  Employee(int i, string n) : id(i), name(n) {}
  void print() const {
    cout << "[" << id << "] " << name << endl;
  }
};

int main() {
  Employee staff[3] = {
    Employee(101, "Nguyen Van A"),
    Employee(102, "Tran Thi B"),
    Employee(103, "Le Van C")
  };

  for (int i = 0; i < 3; i++) {
    staff[i].print(); // dot operator with index
  }
  return 0;
}

// Base Class (Parent)
class Employee {
protected:
  string name;
  double baseSalary;
public:
  Employee(string n, double s)
    : name(n), baseSalary(s) {}
  void printBase() const {
    cout << name << " | Base: " << baseSalary;
  }
};

// Derived Class: "Developer IS AN Employee"
class Developer : public Employee {
private:
  string techStack;
public:
  Developer(string n, double s, string tech)
    : Employee(n, s), techStack(tech) {}
  void printDev() const {
    printBase();
    cout << " | Tech: " << techStack << endl;
  }
};

class Base {
public:
  Base() {
    cout << "1. Base Constructor" << endl;
  }
  Base(int x) {
    cout << "1. Base Parameterized: " << x << endl;
  }
};

class Derived : public Base {
public:
  // Explicitly pass parameter up to Base
  Derived(int x, int y) : Base(x) {
    cout << "2. Derived Constructor: " << y << endl;
  }
};

int main() {
  Derived obj(10, 20);
  return 0;
}

class Base {
public:
  ~Base() {
    cout << "2. Base Destructor" << endl;
  }
};

class Derived : public Base {
public:
  ~Derived() {
    cout << "1. Derived Destructor" << endl;
  }
};

int main() {
  {
    Derived d;
  } // Scope ends here — both destructors fire
  return 0;
}

class Account {
protected:
  double balance; // accessible to child classes
public:
  Account(double b) : balance(b) {}
  void printStatement() const {
    cout << "Balance: " << balance << endl;
  }
};

class SavingsAccount : public Account {
private:
  double interestRate;
public:
  SavingsAccount(double b, double r)
    : Account(b), interestRate(r) {}

  void applyMonthlyInterest() {
    balance += balance * interestRate; // OK! protected
  }

  void printStatement() const {
    Account::printStatement(); // Explicit base call
    cout << "Interest Rate: "
         << interestRate * 100 << "%" << endl;
  }
};

class Printer {
public:
  void print() const {
    cout << "Standard Black-and-White Print" << endl;
  }
};

class ColorPrinter : public Printer {
public:
  // Override print() with specialized behavior
  void print() const {
    cout << "Vibrant High-Definition Color Print" << endl;
  }
};

int main() {
  Printer p;
  p.print();     // Standard Black-and-White Print

  ColorPrinter cp;
  cp.print();            // Vibrant Color Print
  cp.Printer::print();   // Explicit base version
  return 0;
}

class Employee {
public:
  void introduce() const {
    cout << "I am a general employee." << endl;
  }
};

class Developer : public Employee {
public:
  void introduce() const {
    cout << "I am a C++ software architect." << endl;
  }
};

int main() {
  Developer dev;
  // UPCASTING: Always safe and implicit
  Employee* empPtr = &dev;

  // What does this print?
  empPtr->introduce();
  return 0;
}

class Printable {
public:
  void print() const {
    cout << "Rendering to paper..." << endl;
  }
};

class Serializable {
public:
  void serialize() const {
    cout << "Saving state to JSON..." << endl;
  }
};

// Invoice inherits from BOTH base classes
class Invoice : public Printable, public Serializable {
private:
  double amount;
public:
  Invoice(double a) : amount(a) {}
};

int main() {
  Invoice inv(500000);
  inv.print();     // from Printable
  inv.serialize(); // from Serializable
  return 0;
}

class Shape {
public:
  // Pure virtual: defines WHAT, not HOW
  virtual double calcArea() const = 0;
  virtual double calcPerimeter() const = 0;
  virtual ~Shape() {} // Mandatory virtual destructor!
};

// Shape s; // COMPILE ERROR: Cannot instantiate!

class Circle : public Shape {
private:
  double radius;
public:
  Circle(double r) : radius(r) {}

  // Must implement all pure virtuals!
  double calcArea() const override {
    return 3.14159 * radius * radius;
  }
  double calcPerimeter() const override {
    return 2 * 3.14159 * radius;
  }
};

// C++ Interface: all pure virtual, no data members
class IPayable {
public:
  virtual bool processPayment(double amount) = 0;
  virtual string getProviderName() const = 0;
  virtual ~IPayable() {}
};

class VNPTPayGateway : public IPayable {
public:
  bool processPayment(double amount) override {
    cout << "Processing " << amount
         << " VND via VNPT Pay..." << endl;
    return true;
  }
  string getProviderName() const override {
    return "VNPT Pay";
  }
};

class VietQRMethod : public IPayable {
public:
  bool processPayment(double amount) override {
    cout << "Generating VietQR for "
         << amount << " VND..." << endl;
    return true;
  }
  string getProviderName() const override {
    return "VietQR";
  }
};

class Animal {
public:
  virtual void speak() const {
    cout << "Generic creature sound" << endl;
  }
  virtual ~Animal() {}
};

class Cat : public Animal {
public:
  void speak() const override {
    cout << "Meow Meow!" << endl;
  }
};

class Dog : public Animal {
public:
  void speak() const override {
    cout << "Woof Woof!" << endl;
  }
};

void triggerSound(const Animal* a) {
  a->speak(); // Runtime dispatch!
}

int main() {
  Cat myCat;
  Dog myDog;
  triggerSound(&myCat); // Meow Meow!
  triggerSound(&myDog); // Woof Woof!
  return 0;
}