-module(ephp_parser_class).

-author('manuel@altenwald.com').

-export([st_class/3, st_interface/3, class_name/3]).

-include("ephp.hrl").
-include("ephp_parser.hrl").

-import(ephp_parser, [add_pos/2, new_line/1, remove_spaces/2, inc_pos/1]).

st_interface(<<SP:8, Rest/binary>>, Parser, Interface) when ?IS_SPACE(SP) ->
    st_interface(Rest, inc_pos(Parser), Interface);
st_interface(<<SP:8, Rest/binary>>, Parser, Interface) when ?IS_NEWLINE(SP) ->
    st_interface(Rest, new_line(Parser), Interface);
st_interface(<<A:8, Rest/binary>>, Parser, #class{name = undefined} = I)
    when ?IS_ALPHA(A) orelse A =:= $_ ->
    {Rest0, Parser0, {NS, Name}} = class_name(<<A:8, Rest/binary>>, Parser, []),
    st_interface(Rest0, Parser0, I#class{name = Name, namespace = NS});
st_interface(<<E:8, X:8, T:8, E:8, N:8, D:8, S:8, SP:8, Rest/binary>>, Parser, Interface)
    when ?OR(E, $E, $e)
         andalso ?OR(X, $X, $x)
         andalso ?OR(T, $T, $t)
         andalso ?OR(N, $N, $n)
         andalso ?OR(D, $D, $d)
         andalso ?OR(S, $S, $s)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    {Rest0, Parser0} = remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 5)),
    {Rest1, Parser1, {NS, Extends}} = class_name(Rest0, Parser0, []),
    st_interface(Rest1, Parser1, Interface#class{extends = Extends, extends_ns = NS});
st_interface(<<"{", Rest/binary>>, Parser, Interface) ->
    st_interface_content(Rest, normal_public_level(inc_pos(Parser)), Interface).

st_class(<<SP:8, Rest/binary>>, Parser, Class) when ?IS_SPACE(SP) ->
    st_class(Rest, inc_pos(Parser), Class);
st_class(<<SP:8, Rest/binary>>, Parser, Class) when ?IS_NEWLINE(SP) ->
    st_class(Rest, new_line(Parser), Class);
st_class(<<A:8, Rest/binary>>, Parser, #class{name = undefined} = C)
    when ?IS_ALPHA(A) orelse A =:= $_ ->
    {Rest0, Parser0, {NS, Name}} = class_name(<<A:8, Rest/binary>>, Parser, []),
    st_class(Rest0, Parser0, C#class{name = Name, namespace = NS});
st_class(<<$\\, _/binary>>, Parser, _Class) ->
    ephp_parser:throw_error(eparse, Parser, {<<"\\">>, <<"T_NS_SEPARATOR">>, <<"{">>});
st_class(<<E:8, X:8, T:8, E:8, N:8, D:8, S:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(E, $E, $e)
         andalso ?OR(X, $X, $x)
         andalso ?OR(T, $T, $t)
         andalso ?OR(N, $N, $n)
         andalso ?OR(D, $D, $d)
         andalso ?OR(S, $S, $s)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    {Rest0, Parser0} = remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 5)),
    {Rest1, Parser1, {NS, Extends}} = class_name(Rest0, Parser0, []),
    st_class(Rest1, Parser1, Class#class{extends = Extends, extends_ns = NS});
st_class(<<I:8, M:8, P:8, L:8, E:8, M:8, E:8, N:8, T:8, S:8, SP:8, Rest/binary>>,
         Parser,
         Class)
    when ?OR(I, $I, $i)
         andalso ?OR(M, $M, $m)
         andalso ?OR(P, $P, $p)
         andalso ?OR(L, $L, $l)
         andalso ?OR(E, $E, $e)
         andalso ?OR(N, $N, $n)
         andalso ?OR(T, $T, $t)
         andalso ?OR(S, $S, $s)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    {Rest0, Parser0} = remove_spaces(<<SP:8, Rest/binary>>, add_pos(Parser, 5)),
    {Rest1, Parser1, Implements} = st_implements(Rest0, Parser0, []),
    st_class(Rest1, Parser1, Class#class{implements = Implements});
st_class(<<"{", Rest/binary>>, Parser, Class) ->
    st_class_content(Rest, normal_public_level(inc_pos(Parser)), Class).

st_interface_content(<<SP:8, Rest/binary>>, Parser, Interface) when ?IS_SPACE(SP) ->
    st_interface_content(Rest, inc_pos(Parser), Interface);
st_interface_content(<<SP:8, Rest/binary>>, Parser, Interface) when ?IS_NEWLINE(SP) ->
    st_interface_content(Rest, new_line(Parser), Interface);
st_interface_content(<<"}", Rest/binary>>, Parser, Class) ->
    {Rest, inc_pos(Parser), Class};
st_interface_content(<<";", Rest/binary>>, Parser, Interface) ->
    st_interface_content(Rest, normal_public_level(inc_pos(Parser)), Interface);
st_interface_content(<<"//", Rest/binary>>, Parser, Parsed) ->
    {Rest0, Parser0, _} = ephp_parser:comment_line(Rest, Parser, Parsed),
    st_interface_content(Rest0, Parser0, Parsed);
st_interface_content(<<"#", Rest/binary>>, Parser, Parsed) ->
    {Rest0, Parser0, _} = ephp_parser:comment_line(Rest, Parser, Parsed),
    st_interface_content(Rest0, Parser0, Parsed);
st_interface_content(<<"/*", Rest/binary>>, Parser, Parsed) ->
    {Rest0, Parser0, _} = ephp_parser:comment_block(Rest, Parser, Parsed),
    st_interface_content(Rest0, Parser0, Parsed);
st_interface_content(<<P:8, U:8, B:8, L:8, I:8, C:8, SP:8, Rest/binary>>,
                     Parser,
                     Interface)
    when ?OR(P, $P, $p)
         andalso ?OR(U, $U, $u)
         andalso ?OR(B, $B, $b)
         andalso ?OR(L, $L, $l)
         andalso ?OR(I, $I, $i)
         andalso ?OR(C, $C, $c)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_interface_content(<<SP:8, Rest/binary>>, public_level(add_pos(Parser, 6)), Interface);
st_interface_content(<<P:8, R:8, I:8, V:8, A:8, T:8, E:8, SP:8, Rest/binary>>,
                     Parser,
                     Interface)
    when ?OR(P, $P, $p)
         andalso ?OR(R, $R, $r)
         andalso ?OR(I, $I, $i)
         andalso ?OR(V, $V, $v)
         andalso ?OR(A, $A, $a)
         andalso ?OR(T, $T, $t)
         andalso ?OR(E, $E, $e)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_interface_content(<<SP:8, Rest/binary>>, private_level(add_pos(Parser, 7)), Interface);
st_interface_content(<<P:8, R:8, O:8, T:8, E:8, C:8, T:8, E:8, D:8, SP:8, Rest/binary>>,
                     Parser,
                     Interface)
    when ?OR(P, $P, $p)
         andalso ?OR(R, $R, $r)
         andalso ?OR(O, $O, $o)
         andalso ?OR(T, $T, $t)
         andalso ?OR(E, $E, $e)
         andalso ?OR(C, $C, $c)
         andalso ?OR(D, $D, $d)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_interface_content(<<SP:8, Rest/binary>>,
                         protected_level(add_pos(Parser, 9)),
                         Interface);
st_interface_content(<<S:8, T:8, A:8, T:8, I:8, C:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(S, $S, $s)
         andalso ?OR(T, $T, $t)
         andalso ?OR(A, $A, $a)
         andalso ?OR(I, $I, $i)
         andalso ?OR(C, $C, $c)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_interface_content(<<SP:8, Rest/binary>>, static_level(add_pos(Parser, 6)), Class);
st_interface_content(<<F:8, U:8, N:8, C:8, T:8, I:8, O:8, N:8, SP:8, Rest/binary>>,
                     #parser{level = Type,
                             access = RawAccess,
                             final = Final} =
                         Parser,
                     #class{methods = Methods} = Interface)
    when ?OR(F, $F, $f)
         andalso ?OR(U, $U, $u)
         andalso ?OR(N, $N, $n)
         andalso ?OR(C, $C, $c)
         andalso ?OR(T, $T, $t)
         andalso ?OR(I, $I, $i)
         andalso ?OR(O, $O, $o)
         andalso ?IS_SPACE(SP) ->
    {Rest0, Parser0, [#function{} = Fun]} =
        ephp_parser_func:st_function(Rest, add_pos(Parser, 9), []),
    % TODO: if code is defined it should to throw an error or only ignore it?
    Method =
        #class_method{name = Fun#function.name,
                      args = Fun#function.args,
                      type = Type,
                      access = access(RawAccess),
                      final = Final},
    NewInterface = Interface#class{methods = Methods ++ [Method]},
    st_interface_content(Rest0, normal_public_level(Parser0), NewInterface);
st_interface_content(<<C:8, O:8, N:8, S:8, T:8, SP:8, Rest/binary>>,
                     Parser,
                     #class{constants = Constants} = Interface)
    when ?OR(C, $c, $C)
         andalso ?OR(O, $o, $O)
         andalso ?OR(N, $n, $N)
         andalso ?OR(S, $s, $S)
         andalso ?OR(T, $t, $T)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    % FIXME assign when a left-constant should be converted in a simple constant
    {Rest0, Parser0, #assign{variable = #constant{} = Cons, expression = Value}} =
        ephp_parser_expr:expression(<<SP:8, Rest/binary>>, add_pos(Parser, 5), []),
    Constant = #class_const{name = Cons#constant.name, value = Value},
    NewInterface = Interface#class{constants = Constants ++ [Constant]},
    st_interface_content(Rest0, normal_public_level(Parser0), NewInterface).

st_class_content(<<SP:8, Rest/binary>>, Parser, Class) when ?IS_SPACE(SP) ->
    st_class_content(Rest, inc_pos(Parser), Class);
st_class_content(<<SP:8, Rest/binary>>, Parser, Class) when ?IS_NEWLINE(SP) ->
    st_class_content(Rest, new_line(Parser), Class);
st_class_content(<<"}", Rest/binary>>, Parser, Class) ->
    NewParser = inc_pos(Parser),
    {Rest, NewParser, ephp_parser:add_line(Class, NewParser)};
st_class_content(<<";", Rest/binary>>, Parser, Class) ->
    st_class_content(Rest, normal_public_level(inc_pos(Parser)), Class);
st_class_content(<<"//", Rest/binary>>, Parser, Parsed) ->
    {Rest0, Parser0, _} = ephp_parser:comment_line(Rest, Parser, Parsed),
    st_class_content(Rest0, Parser0, Parsed);
st_class_content(<<"#", Rest/binary>>, Parser, Parsed) ->
    {Rest0, Parser0, _} = ephp_parser:comment_line(Rest, Parser, Parsed),
    st_class_content(Rest0, Parser0, Parsed);
st_class_content(<<"/*", Rest/binary>>, Parser, Parsed) ->
    {Rest0, Parser0, _} = ephp_parser:comment_block(Rest, Parser, Parsed),
    st_class_content(Rest0, Parser0, Parsed);
st_class_content(<<P:8, U:8, B:8, L:8, I:8, C:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(P, $P, $p)
         andalso ?OR(U, $U, $u)
         andalso ?OR(B, $B, $b)
         andalso ?OR(L, $L, $l)
         andalso ?OR(I, $I, $i)
         andalso ?OR(C, $C, $c)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_class_content(<<SP:8, Rest/binary>>, public_level(add_pos(Parser, 6)), Class);
st_class_content(<<P:8, R:8, I:8, V:8, A:8, T:8, E:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(P, $P, $p)
         andalso ?OR(R, $R, $r)
         andalso ?OR(I, $I, $i)
         andalso ?OR(V, $V, $v)
         andalso ?OR(A, $A, $a)
         andalso ?OR(T, $T, $t)
         andalso ?OR(E, $E, $e)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_class_content(<<SP:8, Rest/binary>>, private_level(add_pos(Parser, 7)), Class);
st_class_content(<<P:8, R:8, O:8, T:8, E:8, C:8, T:8, E:8, D:8, SP:8, Rest/binary>>,
                 Parser,
                 Class)
    when ?OR(P, $P, $p)
         andalso ?OR(R, $R, $r)
         andalso ?OR(O, $O, $o)
         andalso ?OR(T, $T, $t)
         andalso ?OR(E, $E, $e)
         andalso ?OR(C, $C, $c)
         andalso ?OR(D, $D, $d)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_class_content(<<SP:8, Rest/binary>>, protected_level(add_pos(Parser, 9)), Class);
st_class_content(<<F:8, I:8, N:8, A:8, L:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(F, $F, $f)
         andalso ?OR(I, $I, $i)
         andalso ?OR(N, $N, $n)
         andalso ?OR(A, $A, $a)
         andalso ?OR(L, $L, $l)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_class_content(<<SP:8, Rest/binary>>, final_level(add_pos(Parser, 5)), Class);
st_class_content(<<S:8, T:8, A:8, T:8, I:8, C:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(S, $S, $s)
         andalso ?OR(T, $T, $t)
         andalso ?OR(A, $A, $a)
         andalso ?OR(I, $I, $i)
         andalso ?OR(C, $C, $c)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_class_content(<<SP:8, Rest/binary>>, static_level(add_pos(Parser, 6)), Class);
st_class_content(<<V:8, A:8, R:8, SP:8, Rest/binary>>, Parser, Class)
    when ?OR(V, $V, $v)
         andalso ?OR(A, $A, $a)
         andalso ?OR(R, $R, $r)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    st_class_content(<<SP:8, Rest/binary>>, public_level(add_pos(Parser, 3)), Class);
st_class_content(<<"$", _/binary>> = Rest,
                 #parser{level = Type,
                         access = Access,
                         final = Final} =
                     Parser,
                 #class{attrs = Attrs} = Class)
    when Access =/= undefined orelse Type =:= static ->
    Attr =
        case ephp_parser_expr:expression(Rest, Parser, []) of
            {Rest0, Parser0, #assign{variable = #variable{name = VarName}, expression = Expr}} ->
                #class_attr{access = access(Access),
                            name = VarName,
                            type = Type,
                            init_value = Expr,
                            final = Final,
                            class_name = Class#class.name,
                            namespace = Class#class.namespace};
            {Rest0, Parser0, #variable{name = VarName}} ->
                #class_attr{access = access(Access),
                            name = VarName,
                            type = Type,
                            final = Final,
                            class_name = Class#class.name,
                            namespace = Class#class.namespace}
        end,
    NewClass = Class#class{attrs = Attrs ++ [Attr]},
    case remove_spaces(Rest0, Parser0) of
        {<<",", Rest1/binary>>, Parser1} ->
            st_class_content(Rest1, Parser1, NewClass);
        {Rest1, Parser1} ->
            st_class_content(Rest1, normal_public_level(Parser1), NewClass)
    end;
st_class_content(<<"$", _/binary>> = _Rest, Parser, _Class) ->
    ephp_parser:throw_error(eparse, Parser, {<<"`\"function (T_FUNCTION)\"'">>});
st_class_content(<<F:8, U:8, N:8, C:8, T:8, I:8, O:8, N:8, SP:8, Rest/binary>>,
                 #parser{level = Type,
                         access = RawAccess,
                         final = Final} =
                     Parser,
                 #class{methods = Methods} = Class)
    when ?OR(F, $F, $f)
         andalso ?OR(U, $U, $u)
         andalso ?OR(N, $N, $n)
         andalso ?OR(C, $C, $c)
         andalso ?OR(T, $T, $t)
         andalso ?OR(I, $I, $i)
         andalso ?OR(O, $O, $o)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    {Rest0, Parser0, [#function{} = Fun]} =
        ephp_parser_func:st_function(Rest, add_pos(Parser, 9), []),
    Method =
        #class_method{name = Fun#function.name,
                      args = Fun#function.args,
                      code = Fun#function.code,
                      type = Type,
                      access = access(RawAccess),
                      final = Final},
    NewClass = Class#class{methods = Methods ++ [Method]},
    st_class_content(Rest0, normal_public_level(Parser0), NewClass);
st_class_content(<<C:8, O:8, N:8, S:8, T:8, SP:8, Rest/binary>>,
                 Parser,
                 #class{constants = Constants} = Class)
    when ?OR(C, $c, $C)
         andalso ?OR(O, $o, $O)
         andalso ?OR(N, $n, $N)
         andalso ?OR(S, $s, $S)
         andalso ?OR(T, $t, $T)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    % FIXME assign when a left-constant should be converted in a simple constant
    {Rest0, Parser0, #assign{variable = #constant{} = Cons, expression = Value}} =
        ephp_parser_expr:expression(<<SP:8, Rest/binary>>, add_pos(Parser, 5), []),
    Constant = #class_const{name = Cons#constant.name, value = Value},
    NewClass = Class#class{constants = Constants ++ [Constant]},
    st_class_content(Rest0, normal_public_level(Parser0), NewClass);
st_class_content(<<A:8, B:8, S:8, T:8, R:8, A:8, C:8, T:8, SP:8, Rest/binary>>,
                 Parser,
                 Class)
    when ?OR(A, $A, $a)
         andalso ?OR(B, $B, $b)
         andalso ?OR(S, $S, $s)
         andalso ?OR(T, $T, $t)
         andalso ?OR(R, $R, $r)
         andalso ?OR(C, $C, $c)
         andalso (?IS_SPACE(SP) orelse ?IS_NEWLINE(SP)) ->
    NewParser = abstract_level(add_pos(Parser, 8)),
    st_class_content(<<SP:8, Rest/binary>>, NewParser, Class).

access(undefined) ->
    public;
access(Other) ->
    Other.

get_ns({[<<>>], Name}, _Parser) ->
    {[], Name};
get_ns({NS, Name}, Parser) ->
    RawNS = ephp_parser:get_ns(NS ++ [Name], Parser),
    ephp_ns:split(RawNS).

class_name(<<A:8, Rest/binary>>, Parser, [])
    when ?IS_ALPHA(A) orelse A =:= $_ orelse A =:= $\\ ->
    class_name(Rest, inc_pos(Parser), [<<A:8>>]);
class_name(<<A:8, Rest/binary>>, Parser, [N])
    when ?IS_ALPHA(A) orelse ?IS_NUMBER(A) orelse A =:= $_ orelse A =:= $\\ ->
    class_name(Rest, inc_pos(Parser), [<<N/binary, A:8>>]);
class_name(Rest, Parser, [Parsed]) ->
    ProcessedParsed = get_ns(ephp_ns:parse(Parsed), Parser),
    {Rest, Parser, ProcessedParsed}.

st_implements(<<SP:8, Rest/binary>>, Parser, Parsed) when ?IS_SPACE(SP) ->
    st_implements(Rest, inc_pos(Parser), Parsed);
st_implements(<<SP:8, Rest/binary>>, Parser, Parsed) when ?IS_NEWLINE(SP) ->
    st_implements(Rest, new_line(Parser), Parsed);
st_implements(<<",", Rest/binary>>, Parser, Parsed) ->
    st_implements(Rest, inc_pos(Parser), Parsed);
st_implements(<<A:8, _/binary>> = Rest, Parser, Parsed) when ?IS_ALPHA(A) ->
    {Rest0, Parser0, {NS, Name}} = class_name(Rest, Parser, []),
    st_implements(Rest0, Parser0, [{NS, Name} | Parsed]);
st_implements(<<"{", _/binary>> = Rest, Parser, Parsed) ->
    {Rest, Parser, Parsed}.

normal_public_level(Parser) ->
    Parser#parser{level = normal,
                  final = false,
                  access = undefined}.

public_level(Parser) ->
    Parser#parser{access = public}.

protected_level(Parser) ->
    Parser#parser{access = protected}.

private_level(Parser) ->
    Parser#parser{access = private}.

static_level(Parser) ->
    Parser#parser{level = static}.

abstract_level(Parser) ->
    Parser#parser{level = abstract}.

final_level(Parser) ->
    Parser#parser{final = true}.