resp_redirect, resp_headers, resp_body,

                     host_tokens, port

-author('Bryan Fink <bryan@basho.com>').

-export([dispatch/2, dispatch/3]).

    dispatch([], PathAsString, DispatchList).

%% @spec dispatch(Host::string(), Path::string(),

%%                DispatchList::[matchterm()]) ->

%%         dispterm() | dispfail()

%% @doc Interface for URL dispatching.

%% See also http://bitbucket.org/justin/webmachine/wiki/DispatchConfiguration

dispatch(HostAsString, PathAsString, DispatchList) ->

    {Host, Port} = split_host_port(HostAsString),

    try_host_binding(DispatchList, lists:reverse(Host), Port,

                     Path, ExtraDepth).

split_host_port(HostAsString) ->

    case string:tokens(HostAsString, ":") of

        [HostPart, PortPart] ->

            {split_host(HostPart), list_to_integer(PortPart)};

        [HostPart] ->

            {split_host(HostPart), 80}

    end.

split_host(HostAsString) ->

    string:tokens(HostAsString, ".").

%% @type matchterm() = hostmatchterm() | pathmatchterm()

% first one whose host and path terms match the input is used.

% Using a pathmatchterm() here is equivalent to using a hostmatchterm()

% of the form {{['*'],'*'}, [pathmatchterm()]}.

%% @type hostmatchterm() = {hostmatch(), [pathmatchterm()]}

% The dispatch configuration contains a list of these terms, and the

% first one whose host and one pathmatchterm match is used.

%% @type hostmatch() = [hostterm()] | {[hostterm()], portterm()}

% A host header (Host, X-Forwarded-For, etc.) will be matched against

% this term.  Using a raws [hostterm()] list is equivalent to using

% {[hostterm()], '*'}.

%% @type hostterm() = '*' | string() | atom()

% A list of hostterms is matched against a '.'-separated hostname.

% The '*' hosterm matches all remaining tokens, and is only allowed at

% the head of the list.

% A string hostterm will match a token of exactly the same string.

% Any atom hostterm other than '*' will match any token and will

% create a binding in the result if a complete match occurs.

%% @type portterm() = '*' | integer() | atom()

% A portterm is matched against the integer port after any ':' in

% the hostname, or 80 if no port is found.

% The '*' portterm patches any port

% An integer portterm will match a port of exactly the same integer.

% Any atom portterm other than '*' will match any port and will

% create a binding in the result if a complete match occurs.

%% @type pathmatchterm() = {[pathterm()], matchmod(), matchopts()}.

% The dispatch configuration contains a list of these terms, and the

try_host_binding([], Host, Port, Path, _Depth) ->

    {no_dispatch_match, {Host, Port}, Path};

try_host_binding([Dispatch|Rest], Host, Port, Path, Depth) ->

    {{HostSpec,PortSpec},PathSpec} =

        case Dispatch of

            {{H,P},S} -> {{H,P},S};

            {H,S}     -> {{H,?MATCH_ALL},S};

            S         -> {{[?MATCH_ALL],?MATCH_ALL},[S]}

        end,

    case bind_port(PortSpec, Port, []) of

        {ok, PortBindings} ->

            case bind(lists:reverse(HostSpec), Host, PortBindings, 0) of

                {ok, HostRemainder, HostBindings, _} ->

                    case try_path_binding(PathSpec, Path, HostBindings, Depth) of

                        {Mod, Props, PathRemainder, PathBindings,

                         AppRoot, StringPath} ->

                            {Mod, Props, HostRemainder, Port, PathRemainder,

                             PathBindings, AppRoot, StringPath};

                        {no_dispatch_match, _} ->

                            try_host_binding(Rest, Host, Port, Path, Depth)

                    end;

                fail ->

                    try_host_binding(Rest, Host, Port, Path, Depth)

            end;

        fail ->

            try_host_binding(Rest, Host, Port, Path, Depth)

    end.

bind_port(Port, Port, Bindings) -> {ok, Bindings};

bind_port(?MATCH_ALL, _Port, Bindings) -> {ok, Bindings};

bind_port(PortAtom, Port, Bindings) when is_atom(PortAtom) ->

    {ok, [{PortAtom, Port}|Bindings]};

bind_port(_, _, _) -> fail.

try_path_binding([], PathTokens, _, _) ->

try_path_binding([{PathSchema, Mod, Props}|Rest], PathTokens,

                 Bindings, ExtraDepth) ->

    case bind(PathSchema, PathTokens, Bindings, 0) of

        {ok, Remainder, NewBindings, Depth} ->

            {Mod, Props, Remainder, NewBindings,

            try_path_binding(Rest, PathTokens, Bindings, ExtraDepth)

bind([], [], Bindings, Depth) ->

bind([?MATCH_ALL], Rest, Bindings, Depth) when is_list(Rest) ->

    {ok, Rest, Bindings, Depth + length(Rest)};

bind(_, [], _, _) ->

bind([Token|RestToken],[Match|RestMatch],Bindings,Depth) when is_atom(Token) ->

    bind(RestToken, RestMatch, [{Token, Match}|Bindings], Depth + 1);

bind([Token|RestToken], [Token|RestMatch], Bindings, Depth) ->

    bind(RestToken, RestMatch, Bindings, Depth + 1);

bind(_, _, _, _) ->

    Host = case host_headers(Req) of

               [H|_] -> H;

               [] -> []

           end,

    case webmachine_dispatcher:dispatch(Host, Req:path(), DispatchList) of

        {no_dispatch_match, _UnmatchedHost, _UnmatchedPathTokens} ->

        {Mod, ModOpts, HostTokens, Port, PathTokens, Bindings,

         AppRoot, StringPath} ->

	    Req:load_dispatch_data(Bindings,HostTokens,Port,PathTokens,

                                   AppRoot,StringPath,Req),

host_headers(Req) ->

    [ V || V <- [Req:get_header_value(H)

                 || H <- ["x-forwarded-for",

                          "x-forwarded-host",

                          "x-forwarded-server",

                          "host"]],

           V /= undefined].

	 load_dispatch_data/7,

load_dispatch_data(Bindings, HostTokens, Port, PathTokens,

                   AppRoot, DispPath, Req) ->

    call({load_dispatch_data, Bindings, HostTokens, Port,

          PathTokens, AppRoot, DispPath, Req}).

handle_call({load_dispatch_data, PathProps,HostTokens,Port,

             PathTokens,AppRoot,DispPath,WMReq},

               PathInfo,HostTokens,Port,PathTokens,AppRoot,

               DispPath,WMReq,State#state.reqdata)},

-export([create/4,load_dispatch_data/8]).

         app_root/1,path_tokens/1, host_tokens/1, port/1]).

load_dispatch_data(PathInfo, HostTokens, Port, PathTokens, AppRoot,

                   DispPath, WMReq, RD) ->

    RD#wm_reqdata{path_info=PathInfo,host_tokens=HostTokens,

                  port=Port,path_tokens=PathTokens,

                  app_root=AppRoot,disp_path=DispPath,wmreq=WMReq}.

host_tokens(_RD = #wm_reqdata{host_tokens=HostT}) -> HostT. % list of strings

port(_RD = #wm_reqdata{port=Port}) -> Port. % integer

        {ok, Value} when is_list(Value); is_integer(Value) ->

            Value; % string (for host or path match)

                   % or integer (for port match)