// Abstraction using private methods
class MusicPlayer {
  play(track) {
    this.#loadTrack(track);
    this.#decodeAudio();
    this.#outputToSpeakers();
    console.log(`Playing: ${track.title}`);
  }

  pause() {
    this.#pauseAudio();
  }

  // Private implementation — hidden from users
  #loadTrack(track) {
    // Read file, check format, load into buffer
  }

  #decodeAudio() {
    // MP3/AAC/FLAC decoding
  }

  #outputToSpeakers() {
    // DAC conversion, amplification
  }

  #pauseAudio() {
    // Stop output, save position
  }
}

const player = new MusicPlayer();
player.play({ title: "Bohemian Rhapsody", artist: "Queen" });
// User doesn't need to know about audio decoding!

// Abstract class defines WHAT, not HOW
abstract class ReportGenerator {
  // Template method — defines the algorithm structure
  generate(data: any[]): string {
    const header = this.createHeader();
    const body = this.createBody(data);
    const footer = this.createFooter();
    return header + body + footer;
  }

  // Abstract methods — subclasses provide implementation
  protected abstract createHeader(): string;
  protected abstract createBody(data: any[]): string;
  protected abstract createFooter(): string;
}

// Concrete implementation
class HTMLReport extends ReportGenerator {
  protected createHeader(): string {
    return "<html><body><h1>Report</h1>";
  }
  protected createBody(data: any[]): string {
    return "<table>" + data.map(d => `<tr><td>${d}</td></tr>`).join("") + "</table>";
  }
  protected createFooter(): string {
    return "</body></html>";
  }
}

// Another implementation
class JSONReport extends ReportGenerator {
  protected createHeader(): string { return "["; }
  protected createBody(data: any[]): string {
    return JSON.stringify(data);
  }
  protected createFooter(): string { return "]"; }
}

function generateReport(report: ReportGenerator, data: any[]) {
  console.log(report.generate(data));
  // Works with any ReportGenerator!
}

from abc import ABC, abstractmethod

class Database(ABC):
    """Abstract base class — defines the interface."""

    @abstractmethod
    def connect(self) -> None:
        pass

    @abstractmethod
    def query(self, sql: str) -> list:
        pass

    @abstractmethod
    def disconnect(self) -> None:
        pass

    # Concrete method that uses abstract methods
    def find_user(self, user_id: int) -> dict:
        """High-level operation using abstract primitives."""
        self.connect()
        result = self.query(f"SELECT * FROM users WHERE id = {user_id}")
        self.disconnect()
        return result[0] if result else None

class PostgreSQL(Database):
    def connect(self) -> None:
        print("Connecting to PostgreSQL...")

    def query(self, sql: str) -> list:
        print(f"Executing: {sql}")
        return [{"id": 1, "name": "Alice"}]

    def disconnect(self) -> None:
        print("Disconnecting...")

class MySQL(Database):
    def connect(self) -> None:
        print("Connecting to MySQL...")

    def query(self, sql: str) -> list:
        print(f"Executing: {sql}")
        return [{"id": 1, "name": "Alice"}]

    def disconnect(self) -> None:
        print("Disconnecting...")

// Interface — pure abstraction
interface PaymentProcessor {
    void processPayment(double amount);
    void refund(String transactionId);
}

// Concrete implementation 1
class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // Connect to credit card network
        // Validate card details
        // Process transaction
        System.out.println("Processing credit card payment: $" + amount);
    }

    @Override
    public void refund(String transactionId) {
        System.out.println("Refunding transaction: " + transactionId);
    }
}

// Concrete implementation 2
class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        // Connect to PayPal API
        // Handle OAuth
        // Process transaction
        System.out.println("Processing PayPal payment: $" + amount);
    }

    @Override
    public void refund(String transactionId) {
        System.out.println("Refunding via PayPal: " + transactionId);
    }
}

// Client code works with abstraction, not implementation
class CheckoutService {
    private PaymentProcessor processor;

    public CheckoutService(PaymentProcessor processor) {
        this.processor = processor;
    }

    public void checkout(double amount) {
        processor.processPayment(amount);
    }
}