package se.chalmers.cs.pgf;

import se.chalmers.cs.pgf.raw.*;

import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.IOException;
import java.io.StringReader;

public class PGF {

    private String name;

    private String startCat;
    
    private Abstract abstractSyntax;

    private Map<String,Concrete> concreteSyntaxes;


    public String getStartCat () {
	return startCat;
    }

    public String getName() {
	return name;
    }

    public Set<String> getCategories() {
	return abstractSyntax.getCategories();
    }

    public Map<String, Function> getFunctions() {
	return abstractSyntax.getFunctions();
    }

    Abstract getAbstract() {
	return abstractSyntax;
    }

    Concrete getConcrete(String lang) {
	Concrete cnc = concreteSyntaxes.get(lang);
	/*
	if (cnc == null)
	    throw new NotFoundException("Unknown concrete syntax: " + lang);
	*/
	return cnc;
    }


    public String toString() {
	return "Abstract: " + abstractSyntax + "\nConcretes: " + concreteSyntaxes;
    }

    /** Parses in the start category. */
    public List<Term> parse(String lang, String input) {
	return parse(lang, startCat, input);
    }

    public List<Term> parse(String lang, String cat, String input) {
	// FIXME: cache parsers
	return new Parser(getConcrete(lang)).parse(cat,input);
    }

    public String linearize(String lang, Term tree) {
	return new Linearizer(getConcrete(lang)).linearize(tree);
    }

    public static Term readTree(String str) {
	return PGFParser.parseTerm(str);
    }

    public static PGF readPGF(String file) throws IOException {
	CharSequence input = readFileUTF8(file);	
	Grm grm = PGFParser.parseGrm(input);
	return buildPGF(grm);	    
    }

    private static CharSequence readFileUTF8(String file) throws IOException {
	Reader r = new InputStreamReader(new FileInputStream(file), "UTF-8");
	StringBuilder sb = new StringBuilder();
	char[] buf = new char[4096];
	int len;
	while ((len = r.read(buf)) != -1) {
	    sb.append(buf, 0, len);
	}
	return sb;
    }

    private static PGF buildPGF(Grm grm) {
	final PGF pgf = new PGF();
	(new FunVisitor() {
		public void visitFun(String ident, Term[] terms) {
		    if (ident.equals("pgf")) {
			pgf.name = ((Fun)terms[2]).id_;
		    } else if (ident.equals("abstract")) {
			pgf.abstractSyntax = new Abstract(terms);
		    } else if (ident.equals("concrete")) {
			pgf.concreteSyntaxes = new HashMap<String,Concrete>();
			for (Term t : terms) {
			    Fun f = (Fun)t;
			    pgf.concreteSyntaxes.put(f.id_, new Concrete(f.id_, f.listterm_));
			}
		    }
		}
	    }).visitAll(grm.listterm_);

	return pgf;
    }

}