/**
 * Warranty & Liability
 * To the extent permitted by applicable law and unless explicitly
 * otherwise agreed upon, XLOG Technologies AG makes no warranties
 * regarding the provided information. XLOG Technologies AG assumes
 * no liability that any problems might be solved with the information
 * provided by XLOG Technologies AG.
 *
 * Rights & License
 * All industrial property rights regarding the information - copyright
 * and patent rights in particular - are the sole property of XLOG
 * Technologies AG. If the company was not the originator of some
 * excerpts, XLOG Technologies AG has at least obtained the right to
 * reproduce, change and translate the information.
 *
 * Reproduction is restricted to the whole unaltered document. Reproduction
 * of the information is only allowed for non-commercial uses. Selling,
 * giving away or letting of the execution of the library is prohibited.
 * The library can be distributed as part of your applications and libraries
 * for execution provided this comment remains unchanged.
 *
 * Restrictions
 * Only to be distributed with programs that add significant and primary
 * functionality to the library. Not to be distributed with additional
 * software intended to replace any components of the library.
 *
 * Trademarks
 * Jekejeke is a registered trademark of XLOG Technologies AG.
 */

/**
 * get_message(M, A):
 * get_message(M, L, A):
 * The predicate succeeds in writing the message M formatted
 * by the template strings into a new atom A. The predicate
 * fails if no template string can be found. The ternary
 * predicate allows specifying a locale L.
 */
% get_message(+Term, -Atom)
get_message(Message, Atom) :-
   current_prolog_flag(sys_locale, Locale),
   get_message(Message, Locale, Atom).

% get_message(+Term, +Atom, -Atom)
get_message(Message, Locale, Atom) :-
   sys_split_message(Message, Locale, Template, Args), !,
   format_atom(Template, Args, Atom).

/**
 * put_message(S, M):
 * put_message(S, M, L):
 * The predicate succeeds in writing the message M formatted
 * by the template strings to the output stream S. If no
 * template string can be found a wrapper is written. The
 * ternary predicate allows specifying a locale L.
 */
% put_message(+Stream, +Term)
put_message(Stream, Message) :-
   current_prolog_flag(sys_locale, Locale),
   put_message(Stream, Message, Locale).

% put_message(+Stream, +Term, +Atom)
put_message(Stream, Message, Locale) :- var(Message), !,
   put_message(Stream, exception(template, Message), Locale).
put_message(Stream, Message, Locale) :-
   sys_split_message(Message, Locale, Template, Args), !,
   format(Stream, Template, Args).
put_message(Stream, Message, Locale) :-
   put_message(Stream, exception(template, Message), Locale).

% sys_split_message(+Term, +Locale, +Atom, -List)
sys_split_message(Message, Locale, Atom, Args) :- Message =.. [Fun|Args],
   atom(Fun),
   sys_locale_string(Fun, Locale, Atom).
sys_split_message(Message, Locale, Atom, Args) :- Message =.. [Fun, Type|Args],
   atom(Fun), atom(Type),
   atom_join([Fun,'.',Type], Key),
   sys_locale_string(Key, Locale, Atom).
sys_split_message(Message, Locale, Atom, Args) :- Message =.. [Fun, Type1, Type2|Args],
   atom(Fun), atom(Type1), atom(Type2),
   atom_join([Fun,'.',Type1,'.',Type2], Key),
   sys_locale_string(Key, Locale, Atom).

% sys_locale_string(+Atom, +Atom, -Atom)
sys_locale_string(Key, Locale, Value) :-
   sys_locale_ancestor(Locale, Locale2),
   strings(Key, Locale2, Value).

% sys_locale_ancestor(+Atom, -Atom)
sys_locale_ancestor('', '') :- !.
sys_locale_ancestor(L, L).
sys_locale_ancestor(L, M) :-
   last_sub_atom(L, P, _, _, '_'),
   sub_atom(L, 0, P, _, M).
sys_locale_ancestor(_, '').

/*********************************************************************/
/* Time Format                                                       */
/*********************************************************************/

/**
 * atom_time(A, F, T):
 * atom_time(A, F, T, L):
 * If A is a variable, the built-in succeeds in A with the millisecond
 * time T formatted by the pattern F. Otherwise the built-in succeeds
 * in T with the millisecond time parsed from A by the pattern F. The
 * quaternary predicate allows specifying time options.
 */
% atom_time(+-Atom, +Atom, -+Integer)
atom_time(A, F, T) :-
   os_atom_time(A, F, 0, T).

% atom_time(+-Atom, +Atom, -+Integer, +List)
atom_time(A, F, T, L) :-
   sys_time_opts(L, 0, O),
   os_atom_time(A, F, O, T).

% sys_time_opts(+List, +Integer, -Integer)
sys_time_opts(V, _, _) :- var(V),
   throw(error(instantiation_error,_)).
sys_time_opts([X|L], F, G) :- !,
   sys_time_opt(X, F, H),
   sys_time_opts(L, H, G).
sys_time_opts([], F, F) :- !.
sys_time_opts(L, _, _) :-
   throw(error(type_error(list,L),_)).

% sys_time_opt(+Term, +Integer, -Integer)
sys_time_opt(V, _, _) :- var(V),
   throw(error(instantiation_error,_)).
sys_time_opt(face(F), _, G) :- !,
   sys_check_face(F, G).
sys_time_opt(O, _, _) :-
   throw(error(domain_error(time_option,O),_)).

% sys_check_face(+Boolean, -Integer)
sys_check_face(V, _) :- var(V),
   throw(error(instantiation_error,_)).
sys_check_face(local, 0) :- !.
sys_check_face(utc, 1) :- !.
sys_check_face(B, _) :-
   throw(error(domain_error(face,B),_)).

/****************************************************************/
/* Error Texts                                                  */
/****************************************************************/

% strings(+Atom, +Atom, -Atom)
:- multifile(strings/3).
strings('domain_error.time_option', de, 'Zeitoption erwartet, gefunden ~q.').
strings('domain_error.face', de, 'Face erwartet, gefunden ~q.').

strings('domain_error.time_option', '', 'Time option expected, found ~q.').
strings('domain_error.face', '', 'Face expected, found ~q.').

/*******************************************************************/
/* Foreign Predicates                                              */
/*******************************************************************/

% os_atom_time(X, Y, Z, T):
% defined in foreign(text/intlib)

:- ensure_loaded(foreign(text/intlib)).