import uk.me.nxg.lx.reader.LxReader;
import uk.me.nxg.lx.helpers.MultiParser;
import uk.me.nxg.lx.helpers.LxWriter;
import uk.me.nxg.lx.LxException;

import java.io.File;
import java.io.FileReader;

import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.Source;
import javax.xml.transform.Result;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

/**
 * Simple converter, which performs the identity transformation.
 * Usage is simple: 
 * <pre>
 *   java identity input.{lx|xml} [output.{lx,xml}]
 * </pre>
 */
public class identity {

    private static final int XML_FORMAT = 0;
    private static final int LX_FORMAT = 1;
    private static final int SD_FORMAT = 2;

    public static void main(String args[]) {

	if (args.length == 0) {
            Usage();
	}

	int status = 1;         // error!

        String inputFile = args[0];
        String[] inputFileParts = inputFile.split(":", 2);
        int inputFormat = -1;
        if (inputFileParts.length == 2) {
            inputFile = inputFileParts[0];
            inputFormat = getFormat(inputFileParts[1]);
        } else {
            inputFormat = getFormat(inputFile);
        }
        if (inputFormat < 0) {
            System.err.println("Unrecognised format in file " + inputFile);
            System.exit(1);
        }

        int outputFormat;
        String outputFile;
        if (args.length > 1) {
            // There is a second argument -- output file name
            outputFile = args[1];
            String[] outputFileParts = outputFile.split(":", 2);
            if (outputFileParts.length == 2) {
                outputFile = outputFileParts[0];
                outputFormat = getFormat(outputFileParts[1]);
            } else {
                outputFormat = getFormat(outputFile);
            }
        } else {
            String outputExtension;
            if (inputFormat == LX_FORMAT) {
                outputFormat = XML_FORMAT;
                outputExtension = ".xml";
            } else {
                outputFormat = LX_FORMAT;
                outputExtension = ".lx";
            }
            outputFile = inputFile.replaceFirst("\\.[^.]*$", outputExtension);
        }

        System.err.println("input file <" + inputFile
                           + ">, format " + inputFormat
                           + "; output file <" + outputFile
                           + ">, format " + outputFormat);

	try {

	    Source s = new SAXSource
                    (new uk.me.nxg.lx.helpers.MultiParser(),
                     new InputSource(new FileReader(inputFile)));

	    Result r = null;
            switch (outputFormat) {
              case XML_FORMAT:
                r = new StreamResult(new File(outputFile));
                break;
              case LX_FORMAT:
                r = new SAXResult(new LxWriter(new File(outputFile)));
                break;
              case SD_FORMAT:
                r = new SAXResult(new uk.me.nxg.lx.helpers.SaxDumpWriter
                                  (new File(outputFile)));
                break;
              default:
                System.err.println("Unrecognised output format "
                                   + outputFormat);
                System.exit(1);
            }
            // assert r != null;

	    Transformer t = TransformerFactory.newInstance().newTransformer();
	    
	    t.transform(s, r);

            status = 0;         // success!
            
	} catch (java.io.FileNotFoundException e) {
	    System.err.println("Can't find file " + e);
        } catch (java.io.IOException e) {
            System.err.println("IO Exception: " + e);
	} catch (javax.xml.transform.TransformerException e) {
	    System.err.println("Exception: " + e);
	}

	System.exit(status);
    }

    private static void Usage() {
        System.err.println("Usage: java identity filename.{lx|xml} [output.{lx,xml}]");
        System.exit(1);
    }

    /** 
     * Check which format the string represents.
     * @return one of the format integers, or negative on error
     */
    private static int getFormat(String f) {
        if (f.endsWith("lx"))
            return LX_FORMAT;
        if (f.endsWith("xml"))
            return XML_FORMAT;
        if (f.endsWith("sd"))
            return SD_FORMAT;
        return -1;
    }
}