import haxe.macro.Context;

class HelloMacro {
    public static function hello():Void {
        Context.error("Something Wrong!?", Context.makePosition({min:0, max:2, file:"HelloMacro.hx"}));
    }
}

#if macro
class Macro {}
#else
class Main {}
#end

import haxe.Resource;
import haxe.io.Bytes;

#if macro
import haxe.macro.Context;
#end

class EmbeddingDate {
    public static var DATE_RESOURCE_KEY = "dateResource";

    #if macro
    public static function initialize():Void {
        // 初期化マクロのエントリーポイント

        // 現在時刻を取得して文字列に
        var dateString = Date.now().toString();

        // 文字列をリソースとして埋め込み
        Context.addResource(DATE_RESOURCE_KEY, Bytes.ofString(dateString));
    }
    #end

    public static function main():Void {
        // アプリの実行時のエントリーポイント

        // リソースからビルド日時を取り出して出力
        trace(Resource.getString(DATE_RESOURCE_KEY));
    }
}

#if macro
import haxe.macro.Compiler;
#end

// externクラス
extern class SampleExtern {
    public static function test():Void;
    public static function test2():Void;
    public static function test3():Void;
}

class PatchExtern {
    #if macro
    public static function initialize():Void {
        // SampleExtern.testに非推奨のタグ付け
        Compiler.addMetadata("@:deprecated", "SampleExtern", "test", true);

        // SampleExtern.test2を削除
        Compiler.removeField("SampleExtern", "test2", true);

        // SampleExtern.test3の戻り値をStringに変更
        Compiler.setFieldType("SampleExtern", "test3", "String", true);
    }
    #else
    public static function main():Void {
        // コンパイル時に非推奨の警告が表示される
        SampleExtern.test();

        // アクセスしようとするとエラー
        // SampleExtern.test2();

        // 戻り値がStringに変更されているので、traceの引数に使える
        trace(SampleExtern.test3());
    }
    #end
}

import haxe.macro.Compiler;

class IncludeMacro {
    public static function initialize():Void {
        // libパッケージ以下のすべての型をコンパイル対象に指定
        Compiler.include("lib", true);
    }
}

package lib;

class IncludeSample {
    public function new() {
        trace(Math.random());
    }
}

import lib.IncludeSample;

#if macro
import haxe.macro.Compiler;
#end

class ExcludeSample {
    public function new() {
        new IncludeSample();
    }

    #if macro
    public static function initialize():Void {
        // libパッケージ以下を、出力結果に含めない
        Compiler.exclude("lib");
    }
    #end
}

import haxe.macro.Context;
import haxe.macro.Expr;

class ExprMacro {
    public static macro function twice(expr:Expr):Expr {
        return {
            expr: ExprDef.EBlock([expr, expr]),
            pos: Context.currentPos(),
        }
    }
}

class ExprMacroSample {
    static function main() {
        var i = 0;
        ExprMacro.twice(i += 4);
        trace(i); // 8
    }
}

    static function main() {
        var i = 0;
        {
            i += 4;
            i += 4;
        }
        trace(i); // 8
    }

class BenchmarkSample {
    static function main() {
        var time = Date.now().getTime();

        // 何か時間のかかる処理
        for (i in 0...100000) {}

        trace((time - Date.now().getTime()) + "ms");
    }
}

import haxe.macro.Expr;

class ExprMacro {
    public static macro function bench(target:Expr):Expr {
        return macro {
            var time = Date.now().getTime();
            $target;
            trace((time - Date.now().getTime()) + "ms");
        }
    }
}

    static function main():Void {
        ExprMacro.bench(
            for (i in 0...100000) {}
        );
    }

import haxe.macro.Context;
import haxe.macro.Expr;

class DebugMacro {
    public static macro function debug() {
        var exprs:Array<Expr> = [];
        for (tvar in Context.getLocalTVars()) {
            // 変数strに"変数の名前 : 変数の中身"の文字列を追加する式を生成
            var expr = macro str += $v{tvar.name} + " : " + $i{tvar.name} + "\n";
            exprs.push(expr);
        }

        // 呼び出し元の関数名を取得
        var methodName = Context.getLocalMethod();

        // 変数strを定義して、用意した式の配列をブロック式化する
        return macro {
            var str = "Called from " + $v{methodName} + "\n";
            $b{exprs}
            trace(str + "--------\n");
        };
    }
}

class DebugMacroSample {
    public static function main() {
        test(100);
    }

    public static function test(hoge:Int) {
        var fuga = "ok";
        DebugMacro.debug();
    }
}

import haxe.macro.Context;
import haxe.macro.Expr;
import haxe.macro.Printer;
import sys.FileSystem;

class BuildMacro {
    public static function addFileNames(directory:String):Array<Field> {
        var fields:Array<Field> = [];

        // ディレクトリ内のファイルに対してループ処理
        for (fileName in FileSystem.readDirectory(directory)) {
            // ファイル名を表す定数の式を作成
            var expr = macro $v{fileName};

            // フィールドを定義して追加。
            // public static inline var 大文字ファイル名 = "ファイル名";
            // の意味になる
            fields.push({
                name : StringTools.replace(fileName, ".", "_").toUpperCase(),
                access : [Access.APublic, Access.AStatic, Access.AInline],
                // 型にnullを指定すると推論をさせる。値はファイル名を表す定数の式
                kind : FieldType.FVar(null, expr),
                // 位置情報は関数の呼び出し元のものを使う
                pos : Context.currentPos(),
                // ドキュメントコメントの追加
                doc : new Printer().printExpr(expr),
            });
        }

        return fields;
    }
}

@:build(BuildMacro.addFileNames("./assets"))
class Constants {}

class ConstantsSample {
    public static function main() {
        trace(Constants.SAMPLE_TXT); // ConstantsSample.hx:3: sample.txt
    }
}

import haxe.macro.Context;
import haxe.macro.Expr.Field;
import haxe.macro.Expr.FieldType;
import haxe.macro.Type.FieldKind;

class BuildMacro {
    public static function methodTrace():Array<Field> {
        // すでに定義されているフィールドを取得
        var fields = Context.getBuildFields();

        for (field in fields) {
            switch (field.kind) {
                case FieldType.FFun(func):
                    // trace用の式を準備
                    var traceArg = macro "auto trace: " + $v{field.name} + "(";

                    // trace用に引数も追加
                    var first = true;
                    for (arg in func.args) {
                        if (!first) {
                            traceArg = macro ${traceArg} + ",";
                        }
                        traceArg = macro ${traceArg} + $i{arg.name};
                        first = false;
                    }

                    traceArg = macro ${traceArg} + ")";

                    // 元の式の実行前にtrace文を差し込む
                    func.expr = macro {
                        trace(${traceArg});
                        ${func.expr};
                    }

                case _:
                    // 関数以外には何もしない。
            }
        }

        return fields;
    }
}

@:build(BuildMacro.methodTrace())
class TraceSample {
    public static function main():Void {
        for (i in 0...2) {
            for (j in 0...3) {
                test(i, j);
            }
        }
    }

    public static function test(i:Int, j:Int):Void {}
}

import haxe.macro.Context;
import haxe.macro.Type;

class Linter {
    // 初期化マクロとして呼び出す用
    public static function initialize():Void {
        Context.onGenerate(lint);
    }

    private static function lint(types:Array<Type>):Void {
        for (type in types) {
            switch (type) {
                case Type.TInst(ref, _):
                    var classType = ref.get();
                    lintFields(classType.statics.get());
                    lintFields(classType.fields.get());

                case Type.TAbstract(ref, _):
                    var abstractType = ref.get();
                    lintFields(abstractType.array);

                case _:
            }
        }
    }

    // フィールドに対するチェック
    private static function lintFields(fields:Array<ClassField>):Void {
        for (field in fields) {
            switch (field.kind) {
                case FieldKind.FVar(VarAccess.AccInline, _):
                    // インライン変数をチェックから除外

                case _:
                    // フィールド名のケースがおかしくないか判定。
                    if (!isValidFieldName(field.name)) {
                        Context.warning("should be lower camlcase", field.pos);
                    }
            }
        }
    }

    // 変数名がローワーキャメルケースであることのチェック
    private static function isValidFieldName(name:String):Bool {
        if (StringTools.startsWith(name, "get_") || StringTools.startsWith(name, "set_")) {
            // getter、setter用のサフィックスを除外
            name = name.substr(4);
        } else {
            // 先頭の_は使用可
            while (name.substr(0, 1) == "_") {
                name = name.substr(1);
            }
        }

        if (name.length == 0) { return false;　}

        // スネークケースでないことのチェック
        if (name.indexOf("_") != -1) { return false; }

        // 小文字始まりであることのチェック
        var charCode = name.charCodeAt(0);
        if (charCode < 97 || 122 < charCode) { return false; }

        return true;
    }
}

class LintSample {
    public static function main():Void {
        Test();
        test_test();
    }

    // 大文字始まり
    public static function Test():Void {}

    // スネークケース
    public static function test_test():Void {}
}

import haxe.macro.Compiler;
import haxe.macro.Context;
import sys.io.File;

class LicenseWriter {
    // 初期化マクロとして呼び出す用
    public static function initialize():Void {
        Context.onAfterGenerate(write);
    }

    private static function write():Void {
        var fileName = Compiler.getOutput();
        var comment = "/*This is MIT License.*/\n";

        File.saveContent(fileName, comment + File.getContent(fileName));
    }
}