Standalone.java

package org.etsi.mts.tdl.standalone;

import java.io.File;
import java.io.FilenameFilter;
import java.net.URL;
import java.security.CodeSource;
import java.security.ProtectionDomain;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.epsilon.evl.execute.UnsatisfiedConstraint;
import org.eclipse.ocl.pivot.ExpressionInOCL;
import org.eclipse.ocl.pivot.utilities.OCL;
import org.eclipse.ocl.pivot.utilities.ParserException;
import org.eclipse.ocl.pivot.utilities.Query;
import org.eclipse.xtext.EcoreUtil2;
import org.etsi.mts.tdl.GateType;
import org.etsi.mts.tdl.Package;
import org.etsi.mts.tdl.tdlPackage;
import org.etsi.mts.tdl.asn2tdl.ASN2TDLTranslator;
import org.etsi.mts.tdl.constraints.evl.Validator;
import org.etsi.mts.tdl.helper.TDLHelper;
import org.etsi.mts.tdl.openapi2tdl.next.OpenAPI2TDLTranslatorNext;
import org.etsi.mts.tdl.tools.to.docx.poi.Generator;
import org.etsi.mts.tdl.transform.AbstractTranslator;

public class Standalone {
	static String sourceExtension = "tdltx";
	static String targetExtension = "tdltx";
	static String openapiExtension = "yaml";
	static String asnExtension = "asn";
	
	public static void main(String[] args) throws Exception {
		Standalone app = new Standalone();
		//folder
		String path = "examples/basics";
		
		path = "examples/basics";
		app.processElements(path, app::listElements);

		//TODO: may fail
		app.processElements(path, app::validate);
		//TODO: may fail
//		app.processElements(path, app::translate);

		TDLHelper.resetResourceSet();
		path = "examples/validation/Example.tdltx";
		//TODO: can only be used in isolation as it interferes with OCL delegates afterwards..
//		app.processElements(path, app::validateOCL);
		//TODO: may fail due to literal value use without data type
//		app.processElements(path, app::validate);
		app.processElements(path, app::exportDoc);
		
		TDLHelper.resetResourceSet();
		path = "examples/openapi";
		app.processElements(path, openapiExtension, app::importOpenAPI);
		//NOTE: keep in mind weird errors if legacy OpenAPI importer is imported as well in manifest (especially if it is first)

		TDLHelper.resetResourceSet();
		path = "examples/asn1";
		app.processElements(path, asnExtension, app::importASN1);
		
		//individual file without dependencies
		TDLHelper.resetResourceSet();
		path = "examples/basics/Sample.tdltx";
		app.processElements(path, app::listElements);

		
		//individual file with missing dependencies
		TDLHelper.resetResourceSet();
		path = "examples/basics/ImportSample.tdltx";
		app.processElements(path, app::listElements);
		//validation will fail due to unresolved items
		
		//TODO: minimal example for TO translation
		//TODO: minimal example for TTCN-3 generation
		//TODO: clean up keywords automatically
	}
	
	private void processElements(String path, Consumer<String> operation) throws Exception {
		processElements(path, sourceExtension, operation);
	}
	
	private void processElements(String path, String extension, Consumer<String> operation) throws Exception {
		File target = new File(path);
		//TODO: make recursive?
		if (target.isDirectory()) {
			FilenameFilter filter = (FilenameFilter) (dir, name) -> name.endsWith(extension);
			File[] files = target.listFiles(filter);
			Arrays.sort(files, (a, b) -> a.getName().compareTo(b.getName()));
			//load all resources first
			if (extension.contains("tdl")) {
				for (File f : files) {
					System.out.println("Loading: "+f.getAbsolutePath());
					TDLHelper.load(f.getAbsolutePath());
				}
				TDLHelper.link();
				TDLHelper.check();
			}
			for (File f : files) {
				System.out.println("Processing: "+f.getAbsolutePath());
				operation.accept(f.getAbsolutePath());
			}
		} else {
			if (extension.contains("tdl")) {
				System.out.println("Loading: "+target.getAbsolutePath());
				TDLHelper.load(target.getAbsolutePath());
				TDLHelper.link();
				TDLHelper.check();
			}
			System.out.println("Processing: "+target.getAbsolutePath());
			operation.accept(target.getAbsolutePath());
		}
	}

	private void listElements(String path) {
		Resource resource = TDLHelper.load(path);
		Package p = (Package) resource.getContents().get(0);
		System.out.println("Package: "+p.getName());
		p.getPackagedElement().forEach(e -> {
			System.out.println("  " + e.getName());
			System.out.println("    " + e.eClass().getName() + " : " + e.getQualifiedName());
		});
	}
	
	private void validate(String path) {
		Resource resource = TDLHelper.load(path);
		Validator validator = new Validator();
		//TODO: make robust against unresolved imports
		//TODO: report parsing / resolution errors
		try {
			List<UnsatisfiedConstraint> violations = validator.validate(resource);
			validator.dumpViolations(violations, true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void validateOCL(String path) {
		Resource resource = TDLHelper.load(path);
		OCL ocl = OCL.newInstance(TDLHelper.getResourceSet());
		EClass contextEClass = tdlPackage.Literals.GATE_TYPE;
		try {
			ExpressionInOCL query = ocl.createQuery(contextEClass,
					"self.allDataTypes()"
					);
			Query queryEval = ocl.createQuery(query);
			for (var o : EcoreUtil2.getAllContentsOfType(resource.getContents().get(0), GateType.class)) {
				System.out.println(o.allDataTypes());
				System.out.println(queryEval.evaluateUnboxed(o));
			}
		} catch (ParserException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	private void translate(String path) {
		Resource resource = TDLHelper.load(path);
		try {
			Resource target = TDLHelper.create(resource.getURI().path() + "." + targetExtension);
			target.getContents().addAll(EcoreUtil.copyAll(resource.getContents()));
			TDLHelper.store(target);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void importData(String path, AbstractTranslator translator) {
		File source = new File(path);
		try {
			translator.setTargetResource(TDLHelper.create(source.getAbsolutePath()+"-generated."+targetExtension));
			translator.initTargetResource(translator.cleanName(source.getName()));
			translator.translate(source.getAbsolutePath());
			TDLHelper.store(translator.getTargetResource());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	private void importOpenAPI(String path) {
		importData(path, new OpenAPI2TDLTranslatorNext());
	}

	private void importASN1(String path) {
		importData(path, new ASN2TDLTranslator());
	}

	private void exportDoc(String path) {
		Resource resource = TDLHelper.load(path);
		Generator generator = new Generator();
		String target = path+".docx";
		try {
			generator.generate(
					resource, target, 
					"Generated from "+resource.getURI().lastSegment(), 
					"TO_4_TABLE_TEMPLATE_EDITHELP"
					);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
//	private void importOpenAPIAll(String path) {
//		File target = new File(path);
//		if (target.isDirectory()) {
//			FilenameFilter filter = (FilenameFilter) (dir, name) -> name.endsWith(sourceExtension);
//			File[] files = target.listFiles(filter);
//			Arrays.sort(files, (a, b) -> a.getName().compareTo(b.getName()));
//			for (File f : files) {
//				importOpenAPISingle(f.getAbsolutePath());
//			}
//		} else {
//			importOpenAPISingle(target.getAbsolutePath());
//		}
//	}

}