// Есть интерфейс Generator, который генерирует чисела в какой-то последовательности.
interface IGenerator {
    getNext: (count?: number) => number[]
}

// Есть класс Client, использующий этот генератор для отображения чисел на экран
class Client {
    private _generator: IGenerator
    constructor(generator: IGenerator) {
        this._generator = generator
    }
    public doWork = () => {
        console.log(this._generator.getNext(5))
    }
}

abstract class Component implements IGenerator {
    protected parent: Component | null = null
    public setParent(parent: Component | null) {
        this.parent = parent
    }
    public getParent(): Component | null {
        return this.parent
    }
    public add(component: Component): void {}
    public remove(component: Component): void {}
    public isComposite(): boolean {
        return false
    }
    public abstract getNext(count?: number): number[]
}

class Composite extends Component {
    protected children: Component[] = []

    public add(component: Component): void {
        this.children.push(component)
        component.setParent(this)
    }

    public remove(component: Component): void {
        const componentIndex = this.children.indexOf(component)
        this.children.splice(componentIndex, 1)

        component.setParent(null)
    }

    public isComposite(): boolean {
        return true
    }

    public getNext(count?: number): number[] {
    const results = []
        for (const child of this.children) {
            results.push(...child.getNext(count))
        }

        return results
    }
}

class Generator extends Component {
    public getNext = (count: number): number[] => {
        let arr = []
        for (let i = 0; i < count; i++) arr.push(i + 1);
        return arr
    }
}
class Generator1 extends Component {
    public getNext = (count: number): number[] => {
        let arr = []
        for (let i = 0; i < count; i++) arr.push(i + 1);
        return arr
    }
}
class Generator2 extends Component {
    public getNext = (count: number): number[] => {
        let arr = []
        for (let i = 0; i < count; i++) arr.push(Math.floor(Math.random( ) * (10)));
        return arr
    }
}
class Generator3 extends Component {
    public getNext = (count: number): number[] => {
        let arr = []
        for (let i = count; i > 0; i--) arr.push(i);
        return arr
    }
}
/*
1) прямая последовательность целых чисел
2) случайные числа
3) обратная последовательность целых чисел
4) композит, объединяющий в себе один и более генераторов (в этом случае, генераторы вызываются поочередно)
5) продемонстрировать работу, когда композит стоит на нескольких уровнях:
*/

const client1 = new Client(new Generator1())
client1.doWork()

const client2 = new Client(new Generator2())
client2.doWork()

const client3 = new Client(new Generator3())
client3.doWork()


const branch1 = new Composite()
branch1.add(new Generator1())
branch1.add(new Generator3())

const client4 = new Client(branch1)
client4.doWork()

const tree = new Composite();
const leftBranch = new Generator2();
const rightBranch = new Composite();
const leftLeaf = new Generator1();
const rightLeaf = new Generator3();
rightBranch.add(leftLeaf);
rightBranch.add(rightLeaf);
tree.add(leftBranch);
tree.add(rightBranch);

const client5 = new Client(tree);
client5.doWork()