// 抽象处理者 Handler
abstract class ATeacher {
    // 链式结构，需要包含一个指向下一个 Handler 的对象
    protected aTeacher: ATeacher;
    setTeacher(teacher: ATeacher): void {
        this.aTeacher = teacher;
    }
    getTeacher(): ATeacher {
        return this.aTeacher;
    }
    abstract handler(level: number): void;
}
// 具体处理者 Concrete Handler
class Teacher extends ATeacher {
    private name: string;
    private something: string;
    constructor(name: string, something: string) {
        super();    // Constructors for derived classes must contain a 'super' call
        this.name = name;
        this.something = something
    }
    handler(level: number): void {
        if (level >= 3) {
            console.log("授课老师同意...");
        } else {
            console.log("授课老师无权受理...");
            this.getTeacher().handler(level);
        }
    }
}
class Moniteur extends ATeacher {
    private name: string;
    private something: string;
    constructor(name: string, something: string) {
        super();    // Constructors for derived classes must contain a 'super' call
        this.name = name;
        this.something = something
    }
    handler(level: number): void {
        let flag: boolean = true;   // 设置为同意
        if (level >= 2) {
            if (flag)
                console.log("辅导员同意...");
            else
                console.log("辅导员不同意...");
        } else {
            console.log("辅导员无权受理...");
            this.getTeacher().handler(level);
        }
    }
}
class Directeur extends ATeacher {
    private name: string;
    private something: string;
    constructor(name: string, something: string) {
        super();    // Constructors for derived classes must contain a 'super' call
        this.name = name;
        this.something = something
    }
    handler(level: number): void {
        let flag: boolean = false;  // 设置为不同意
        if (level >= 1) {
            if (flag)
                console.log("主任同意...");
            else
                console.log("主任不同意...");
        } else {
            console.log("主任无权受理...");
            this.getTeacher().handler(level);
        }
    }
}
let stuName1: string = "Lemon";
let thing: string = "Go home";
let teacher1: ATeacher = new Teacher(stuName1, thing);
let teacher2: ATeacher = new Moniteur(stuName1, thing);
let teacher3: ATeacher = new Directeur(stuName1, thing);
teacher1.setTeacher(teacher2);
teacher2.setTeacher(teacher3);
// 授课老师无权受理...
// 辅导员同意...
teacher1.handler(2);

// 接收者 Receiver
class RStudent {
    clean(name: string): void {
        console.log(name + " begin cleaning...");
    }
    doHomwork(name: string) {
        console.log(name + " begin doing homework...");
    }
}
// 抽象命令类 Command
abstract class Command {
    protected student: RStudent;
    constructor(student: RStudent) {
        this.student = student;
    }
    abstract execute(name: string): void;
}
// 具体命令类 ConcreteCommand
class LiTeacher extends Command {
    constructor(student: RStudent) {
        super(student);
    }
    execute(name: string): void {
        this.student.clean(name);
    }
}
class WangTeacher extends Command {
    constructor(student: RStudent) {
        super(student);
    }
    execute(name: string): void {
        this.student.doHomwork(name);
    }
}
// 调用者 Invoker
class Invoker {
    protected command: Command;
    commands: Command[] = new Array<Command>();
    executeCommand(name:  string): void {
        this.command = this.commands.shift();
        this.command.execute(name);
        console.log("Executing one command...");
    }
    setCommand(command: Command): void {
        console.log(`Here are ${this.commands.length} things must be executed before execute this`);
        this.commands.push(command);
    }
    undoCommand(): void {
        if (this.commands.length) {
            this.commands.pop();
            console.log("Undo command is successful!");
        } else {
            console.log("You shouldn't execute any command after you set it if you want to undo it...");
        }
    }
}
let stuName: string = "Tim";
let stu: RStudent = new RStudent();
let command1: LiTeacher = new LiTeacher(stu);
let command2: WangTeacher = new WangTeacher(stu);
let invoker: Invoker = new Invoker();
invoker.setCommand(command1);   // Here are 0 things must be executed before execute this
invoker.setCommand(command2);   // Here are 1 things must be executed before execute this
invoker.executeCommand(stuName);    // Tim begin cleaning...  \n  Executing one command...
invoker.setCommand(command1);   // Here are 1 things must be executed before execute this
invoker.undoCommand();  // Undo command is successful!
invoker.executeCommand(stuName);    // Tim begin doing homework...  \n  Executing one command...

// 抽象表达式
interface AbstractExpression {
    interpret(age: string, occupation: string): boolean;
}
// 终结符表达式
class TerminalExpression implements AbstractExpression {
    private set: Set<string> = new Set<string>();
    constructor(data: string[]) {
        for (let i in data) {
            this.set.add(data[i]);
        }
    }
    interpret(age: string, occupation: string): boolean {
        if (Number(age) <= 12 || this.set.has(occupation)) {
            return true;
        }
        return false;
    }
}
// 非终结符表达式
class AndExpression implements AbstractExpression {
    private people: AbstractExpression = null;
    constructor(people: AbstractExpression) {
        this.people = people;
    }
    interpret(age: string, occupation: string): boolean {
        return this.people.interpret(age, occupation);
    }
}
// 环境类
class Context {
    private occupations: string[] = ["学生", "老人", "孕妇"];
    private people: AbstractExpression;
    constructor() {
        let occupation: AbstractExpression = new TerminalExpression(this.occupations);
        this.people = new AndExpression(occupation);
    }
    halfPrice(info: string) {
        let info_arr: string[] = info.split("岁");
        let ok: boolean = this.people.interpret(info_arr[0], info_arr[1]);
        if (ok) {
            console.log(`您是${info}，本次费用半价...`);
        } else {
            console.log(`${info}，您不是优惠人群，本次费用全票...`);
        }
    }
}
let sp: Context = new Context();
sp.halfPrice("12岁学生");   // 您是12岁学生，本次费用半价...
sp.halfPrice("8岁儿童");    // 您是8岁儿童，本次费用半价...
sp.halfPrice("20岁学生");   // 您是20岁学生，本次费用半价...
sp.halfPrice("68岁老人");   // 您是68岁老人，本次费用半价...
sp.halfPrice("28岁孕妇");   // 您是28岁孕妇，本次费用半价...
sp.halfPrice("18岁无业游民");   // 18岁无业游民，您不是优惠人群，本次费用全票...

// 学校类，用于聚合
class School {
    private schoolName: string;
    constructor(schoolName: string) {
        this.schoolName = schoolName;
    }
    printName(): void {
        console.log(this.schoolName);
    }
}
// 抽象聚合
interface Aggregate {
    add(school: School): void;
    remove(): School;
    getIterator(): MyIterator;
}
// 具体聚合
class ConcreteAggregate implements Aggregate {
    private schoolList: School[] = new Array<School>();
    add(school: School): void {
        this.schoolList.push(school);
    }
    remove(): School {
        let temp: School = this.schoolList.pop();
        return temp;
    }
    getIterator(): MyIterator {
        return new ConcreteIterator(this.schoolList);
    }
}
// 抽象迭代器
interface MyIterator {
    first(): School;
    next(): School;
    hasNext(): boolean;
    reset(): void;
}
// 具体迭代器
class ConcreteIterator implements MyIterator {
    private schoolList: School[];
    private index: number = -1;
    constructor(schoolList: School[]) {
        this.schoolList = schoolList;
    }
    first(): School {
        let first: School = null;
        if (this.schoolList.length > 0)
            first = this.schoolList[0];
        return first;
    }
    next(): School {
        let next: School = null;
        if (this.hasNext())
            // index 初始值为 -1，所以需要先加
            next = this.schoolList[++this.index];
        return next;
    }
    hasNext(): boolean {
        if (this.index < this.schoolList.length-1)
            return true;
        return false;
    }
    reset(): void {
        this.index = -1;
    }
}
let school1: School = new School("华南师范大学");
let school2: School = new School("北京邮电大学");
let school3: School = new School("东南大学");
let schools: Aggregate = new ConcreteAggregate();
schools.add(school1);
schools.add(school2);
schools.add(school3);
let it: MyIterator = schools.getIterator();
while (it.hasNext()) {
    it.next().printName();  // 依次输出学校名字
}
it.first().printName(); // 华南师范大学
console.log(it.hasNext());  // false，因为 index 已经到末尾了
it.reset(); // 重置 index
console.log(it.hasNext());  // true
schools.remove().printName();   // 东南大学