Putting It All Together

// Enum for Duck Types
enum DuckType {
  Mallard = 'Mallard',
  Muscovy = 'Muscovy',
  Pekin = 'Pekin',
}

// Type for Duck Colors using a union type
type DuckColor = 'White' | 'Brown' | 'Black' | 'Mixed';

// Interface describing the shape of a Duck
interface IDuck {
  name: string;
  age: number;
  type: DuckType;
  color: DuckColor;
  favoriteToy?: string;
}

// Class implementing the IDuck interface
class PondDuck implements IDuck {
  name: string;
  age: number;
  type: DuckType;
  color: DuckColor;
  isFlying: boolean;
  favoriteFood?: string;

  constructor(
    name: string,
    age: number,
    type: DuckType,
    color: DuckColor,
    favoriteFood?: string
  ) {
    this.name = name;
    this.age = age;
    this.type = type;
    this.color = color;
    this.isFlying = false; // Ducks start on the ground
    this.favoriteFood = favoriteFood;
  }

  quack(times = 1): void {
    for (let i = 0; i < times; i++) {
      console.log(`${this.name} the ${this.color} ${this.type} duck says: Quack!`);
    }
  }

  fly(): void {
    if (!this.isFlying) {
      this.isFlying = true;
      console.log(`${this.name} starts flying!`);
    } else {
      console.log(`${this.name} is already flying!`);
    }
  }

  land(): void {
    if (this.isFlying) {
      this.isFlying = false;
      console.log(`${this.name} lands gracefully.`);
    } else {
      console.log(`${this.name} is already on the ground!`);
    }
  }
}

// Developer type and an example developer
type Developer = {
  name: string;
  favoriteDuckType: DuckType;
  skills: string[];
};

const elmer: Developer = {
  name: 'Elmer Code',
  favoriteDuckType: DuckType.Mallard,
  skills: ['TypeScript', 'Debugging', 'Problem Solving', 'Hunting Ducks!'],
};

console.log(`Developer ${elmer.name} is obsessed with ${elmer.favoriteDuckType} ducks!`);

// Create some PondDuck instances
const daffy = new PondDuck('Daffy', 3, DuckType.Mallard, 'Black');
const donald = new PondDuck('Donald', 5, DuckType.Pekin, 'White', 'Corn');
const howard = new PondDuck('Howard', 2, DuckType.Muscovy, 'Brown');

// Explicitly typed duck pond (prevents pushing non-Duck values)
const duckPond: PondDuck[] = [];
duckPond.push(daffy, donald, howard);

// Pure function: receives everything it needs (does not access external state)
function makeAllDucksQuack(ducks: PondDuck[], times = 1): void {
  ducks.forEach((duck) => duck.quack(times));
}

// Impure function example (reads from outer scope). This is less reusable/testable.
function findDuckAndFly_impure(name: string): void {
  const found = duckPond.find((d) => d.name === name);
  if (found) {
    found.fly();
  } else {
    console.warn(`No duck named ${name} found in the pond.`);
  }
}

// Preferred pure version: pass the pond in as an argument
function findDuckAndFly(name: string, pond: PondDuck[]): void {
  const found = pond.find((d) => d.name === name);
  if (found) {
    found.fly();
  } else {
    console.warn(`No duck named ${name} found in the pond.`);
  }
}

// Utility: count ducks by type
function countDucksByType(type: DuckType, pond: PondDuck[]): number {
  return pond.filter((duck) => duck.type === type).length;
}

// Usage examples
makeAllDucksQuack(duckPond, 2);           // All ducks quack twice
findDuckAndFly('Donald', duckPond);       // Donald starts flying!
const mallardCount = countDucksByType(DuckType.Mallard, duckPond);
console.log(`There are ${mallardCount} Mallard ducks in the pond.`);
console.log('Ducks in the pond:', duckPond.map((d) => d.name).join(', '));

// Export for use elsewhere
export { PondDuck, DuckType };