/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.jena.riot.out ;

import static org.apache.jena.riot.system.RiotChars.isDigit;
import static org.apache.jena.riot.system.RiotChars.isPNChars;
import static org.apache.jena.riot.system.RiotChars.isPNCharsBase;
import static org.apache.jena.riot.system.RiotChars.isPNChars_U;

import org.apache.jena.atlas.io.AWriter ;
import org.apache.jena.atlas.lib.CharSpace ;
import org.apache.jena.atlas.lib.Pair ;
import org.apache.jena.datatypes.xsd.XSDDatatype ;
import org.apache.jena.graph.Node ;
import org.apache.jena.irix.IRIException;
import org.apache.jena.irix.IRIs;
import org.apache.jena.irix.IRIx;
import org.apache.jena.riot.system.PrefixMap ;
import org.apache.jena.riot.system.PrefixMapFactory ;

/** Node formatter for Turtle using single line strings */
public class NodeFormatterTTL extends NodeFormatterNT
{
    private final NodeToLabel nodeToLabel;
    private final PrefixMap   prefixMap;
    private final String      baseStrIRI;
    private final IRIx        baseIRI;

    // Turtle: abbreviations for literals but no use of prefixes or base.
    public NodeFormatterTTL() {
        this(null, null, NodeToLabel.createBNodeByLabelEncoded()) ;
    }

    public NodeFormatterTTL(String baseIRI, PrefixMap prefixMap) {
        this(baseIRI, prefixMap, NodeToLabel.createBNodeByLabelEncoded()) ;
    }

    public NodeFormatterTTL(String baseIRI, PrefixMap prefixMap, NodeToLabel nodeToLabel) {
        super(CharSpace.UTF8) ;
        this.nodeToLabel = nodeToLabel ;
        if ( prefixMap == null )
            prefixMap = PrefixMapFactory.create() ;
        this.prefixMap = prefixMap ;
        this.baseStrIRI = baseIRI ;
        if ( baseIRI != null ) {
            this.baseIRI = IRIs.resolveIRI(baseIRI);
            if ( ! this.baseIRI.isReference() )
                throw new IRIException("Not suitable for a base IRI: '"+baseIRI+"'");
        } else
            this.baseIRI = null;
    }

    @Override
    public void formatURI(AWriter w, String uriStr) {
        Pair<String, String> pName = prefixMap.abbrev(uriStr) ;
        // Check if legal
        if ( pName != null ) {
            // Check legal - need to check its legal, not for illegal.
            // The splitter in "abbrev" only has a weak rule.
            String prefix = pName.getLeft() ;
            String localname = pName.getRight() ;

            if ( safePrefixName(prefix, localname) ) {
                w.print(prefix) ;
                w.print(':') ;
                w.print(localname) ;
                return ;
            }
        }

        // Attempt base abbreviation.
        if ( baseIRI != null ) {
            String x = abbrevByBase(uriStr) ;
            if ( x != null ) {
                w.print('<') ;
                w.print(x) ;
                w.print('>') ;
                return ;
            }
        }

        // else
        super.formatURI(w, uriStr) ;
    }

    private String abbrevByBase(String uriStr) {
        if ( baseIRI == null )
            return null;
        IRIx relInput = IRIx.create(uriStr);
        IRIx relativized = baseIRI.relativize(relInput);
        return (relativized==null) ? null : relativized.toString();
    }

    @Override
    public void formatBNode(AWriter w, Node n) {
        String x = nodeToLabel.get(null, n) ;
        w.print(x) ;
    }

    // From NodeFormatterNT:

    // @Override
    // public void formatVar(WriterI w, String name)

    // @Override
    // public void formatLitString(WriterI w, String lex)

    // @Override
    // public void formatLitLang(WriterI w, String lex, String langTag)

    static boolean safePrefixName(String prefix, String localname) {
        return safeForPrefix(prefix) && safeForPrefixLocalname(localname) ;
    }

    // [139s]  PNAME_NS        ::=     PN_PREFIX? ':'
    // [140s]  PNAME_LN        ::=     PNAME_NS PN_LOCAL

    // [167s]  PN_PREFIX       ::=     PN_CHARS_BASE ((PN_CHARS | '.')* PN_CHARS)?
    // [168s]  PN_LOCAL        ::=     (PN_CHARS_U | ':' | [0-9] | PLX) ((PN_CHARS | '.' | ':' | PLX)* (PN_CHARS | ':' | PLX))?

    // [163s]  PN_CHARS_BASE   ::=     [A-Z] | [a-z] | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D] | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
    // [164s]  PN_CHARS_U      ::=     PN_CHARS_BASE | '_'
    // [166s]  PN_CHARS        ::=     PN_CHARS_U | '-' | [0-9] | #x00B7 | [#x0300-#x036F] | [#x203F-#x2040]

    // [169s]  PLX             ::=     PERCENT | PN_LOCAL_ESC
    // [170s]  PERCENT         ::=     '%' HEX HEX
    // [171s]  HEX             ::=     [0-9] | [A-F] | [a-f]
    // [172s]  PN_LOCAL_ESC    ::=     '\' ('_' | '~' | '.' | '-' | '!' | '$' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | ';' | '=' | '/' | '?' | '#' | '@' | '%')

    /* private-testing */
    static boolean safeForPrefix(String str) {
        // PN_PREFIX ::= PN_CHARS_BASE ((PN_CHARS | '.')* PN_CHARS)?
        int N = str.length() ;
        if ( N == 0 )
            return true ;
        int idx = 0 ;
        idx = skip1_PN_CHARS_BASE(str, idx) ;
        if ( idx == -1 )
            return false ;
        idx = skipAny_PN_CHARS_or_DOT(str, idx, N - 1) ;
        if ( idx == -1 )
            return false ;
        idx = skip1_PN_CHARS(str, idx) ;
        if ( idx == -1 )
            return false ;
        return (idx == N) ;
    }

    /* private-testing */static boolean safeForPrefixLocalname(String str) {
        // PN_LOCAL ::=  (PN_CHARS_U | ':' | [0-9] | PLX) ((PN_CHARS | '.' | ':' | PLX)* (PN_CHARS | ':' | PLX))?
        // This code does not consider PLX (which is more than one character).
        int N = str.length() ;
        if ( N == 0 )
            return true ;
        int idx = 0 ;
        idx = skip1_PN_CHARS_U_or_digit_or_COLON(str, idx) ;
        if ( idx == -1 )
            return false ;
        idx = skipAny_PN_CHARS_or_DOT_or_COLON(str, idx, N - 1) ;
        if ( idx == -1 )
            return false ;
        // Final char
        idx = skip1_PN_CHARS_or_COLON(str, idx) ;
        if ( idx == -1 )
            return false ;
        // We got to the end.
        return (idx == N) ;
    }

    // ---- Prefix name : prefix part

    private static int skip1_PN_CHARS_BASE(String str, int idx) {
        char ch = str.charAt(idx) ;
        if ( isPNCharsBase(ch) )
            return idx + 1 ;
        return -1 ;
    }

    private static int skipAny_PN_CHARS_or_DOT(String str, int idx, int max) {
        for (int i = idx; i < max; i++) {
            char ch = str.charAt(i) ;
            if ( !isPNChars(ch) && ch != '.' )
                return i ;
        }
        return max ;
    }

    private static int skip1_PN_CHARS(String str, int idx) {
        char ch = str.charAt(idx) ;
        if ( isPNChars(ch) )
            return idx + 1 ;
        return -1 ;
    }

    // ---- Prefix name : local part

    private static int skip1_PN_CHARS_U_or_digit_or_COLON(String str, int idx) {
        char ch = str.charAt(idx) ;
        if ( isPNChars_U(ch) )
            return idx + 1 ;
        if ( isDigit(ch) )
            return idx + 1 ;
        if ( ch == ':' )
            return idx + 1 ;
        return -1 ;
    }

    private static int skipAny_PN_CHARS_or_DOT_or_COLON(String str, int idx, int max) {
        for (int i = idx; i < max; i++) {
            char ch = str.charAt(i) ;
            if ( !isPNChars(ch) && ch != '.' && ch != ':' )
                return i ;
        }
        return max ;
    }

    private static int skip1_PN_CHARS_or_COLON(String str, int idx) {
        char ch = str.charAt(idx) ;
        if ( isPNChars(ch) )
            return idx + 1 ;
        if ( ch == ':' )
            return idx + 1 ;
        return -1 ;
    }

    // ----

    private static final String dtDecimal = XSDDatatype.XSDdecimal.getURI() ;
    private static final String dtInteger = XSDDatatype.XSDinteger.getURI() ;
    private static final String dtDouble  = XSDDatatype.XSDdouble.getURI() ;
    private static final String dtBoolean = XSDDatatype.XSDboolean.getURI() ;

    @Override
    public void formatLitDT(AWriter w, String lex, String datatypeURI) {
        boolean b = writeLiteralAbbreviated(w, lex, datatypeURI) ;
        if ( b )
            return ;
        writeLiteralWithDT(w, lex, datatypeURI) ;
    }

    protected void writeLiteralWithDT(AWriter w, String lex, String datatypeURI) {
        writeLiteralOneLine(w, lex, datatypeURI);
    }

    protected void writeLiteralOneLine(AWriter w, String lex, String datatypeURI) {
        super.formatLitDT(w, lex, datatypeURI) ;
    }

    /** Write in a short form, e.g. integer.
     * @return True if a short form was output else false.
     */
    protected boolean writeLiteralAbbreviated(AWriter w, String lex, String datatypeURI) {
        if ( dtDecimal.equals(datatypeURI) ) {
            if ( validDecimal(lex) ) {
                w.print(lex) ;
                return true ;
            }
        } else if ( dtInteger.equals(datatypeURI) ) {
            if ( validInteger(lex) ) {
                w.print(lex) ;
                return true ;
            }
        } else if ( dtDouble.equals(datatypeURI) ) {
            if ( validDouble(lex) ) {
                w.print(lex) ;
                return true ;
            }
        } else if ( dtBoolean.equals(datatypeURI) ) {
            // We leave "0" and "1" as-is assuming that if written like that,
            // there was a reason.
            if ( lex.equals("true") || lex.equals("false") ) {
                w.print(lex) ;
                return true ;
            }
        }
        return false ;
    }

    private static boolean validInteger(String lex) {
        int N = lex.length() ;
        if ( N == 0 )
            return false ;
        int idx = 0 ;

        idx = skipSign(lex, idx) ;
        idx = skipDigits(lex, idx) ;
        return (idx == N) ;
    }

    private static boolean validDecimal(String lex) {
        // case : In N3, "." illegal, as is "+." and -." but legal in Turtle.
        int N = lex.length() ;
        if ( N <= 1 )
            return false ;
        int idx = 0 ;

        idx = skipSign(lex, idx) ;
        idx = skipDigits(lex, idx) ; // Maybe none.

        // DOT required.
        if ( idx >= N )
            return false ;

        char ch = lex.charAt(idx) ;
        if ( ch != '.' )
            return false ;
        idx++ ;
        // Digit required.
        if ( idx >= N )
            return false ;
        idx = skipDigits(lex, idx) ;
        return (idx == N) ;
    }

    private static boolean validDouble(String lex) {
        int N = lex.length() ;
        if ( N == 0 )
            return false ;
        int idx = 0 ;

        // Decimal part (except 12. is legal)

        idx = skipSign(lex, idx) ;

        int idx2 = skipDigits(lex, idx) ;
        boolean initialDigits = (idx != idx2) ;
        idx = idx2 ;
        // Exponent required.
        if ( idx >= N )
            return false ;
        char ch = lex.charAt(idx) ;
        if ( ch == '.' ) {
            idx++ ;
            if ( idx >= N )
                return false ;
            idx2 = skipDigits(lex, idx) ;
            boolean trailingDigits = (idx != idx2) ;
            idx = idx2 ;
            if ( idx >= N )
                return false ;
            if ( !initialDigits && !trailingDigits )
                return false ;
        }
        // "e" or "E"
        ch = lex.charAt(idx) ;
        if ( ch != 'e' && ch != 'E' )
            return false ;
        idx++ ;
        if ( idx >= N )
            return false ;
        idx = skipSign(lex, idx) ;
        if ( idx >= N )
            return false ; // At least one digit.
        idx = skipDigits(lex, idx) ;
        return (idx == N) ;
    }

    /**
     * Skip digits [0-9] and return the index just after the digits, which may
     * be beyond the length of the string. May skip zero.
     */
    private static int skipDigits(String str, int start) {
        int N = str.length() ;
        for (int i = start; i < N; i++) {
            char ch = str.charAt(i) ;
            if ( ! isDigit(ch) )
                return i ;
        }
        return N ;
    }

    /** Skip any plus or minus */
    private static int skipSign(String str, int idx) {
        int N = str.length() ;
        char ch = str.charAt(idx) ;
        if ( ch == '+' || ch == '-' )
            return idx + 1 ;
        return idx ;
    }
}
