/*
    * Copyright (C) 2007-2012 Argeo GmbH
    *
    * Licensed 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.argeo.slc.core.execution;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.nio.ByteBuffer;
  import java.nio.CharBuffer;
  import java.nio.channels.FileChannel;
  import java.nio.charset.Charset;
  import java.nio.charset.CharsetDecoder;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.StringTokenizer;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.commons.io.IOUtils;
  import org.argeo.slc.SlcException;
  import org.springframework.beans.factory.FactoryBean;
  import org.springframework.beans.factory.InitializingBean;
  import org.springframework.core.io.ByteArrayResource;
  import org.springframework.core.io.Resource;
  
  /** Experimental and suboptimal */
  public class SedFilteredResource implements FactoryBean<Resource>,
  		InitializingBean {
  	private Resource source;
  
  	private List<String> filters = new ArrayList<String>();
  	private Map<Pattern, String> patterns = new HashMap<Pattern, String>();
  
  	private String charset = "UTF-8";
  	private Charset cs;
  	private CharsetDecoder decoder;
  
  	// private CharsetEncoder encoder;
  
  	public Resource getObject() throws Exception {
  		if (filters.size() == 0)
  			return source;
  
  		// int capacity = 100 * 1024;// 100 KB
  		ByteBuffer bb;
  		if (source instanceof ByteArrayResource) {
  			bb = ByteBuffer.wrap(((ByteArrayResource) source).getByteArray());
  		} else {
  			FileInputStream fis = null;
  			try {
  				File file = source.getFile();
  				fis = new FileInputStream(file);
  				FileChannel fc = fis.getChannel();
  
  				// Get the file's size and then map it into memory
  				int sz = (int) fc.size();
  				bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz);
  			} catch (IOException e) {
  				// ReadableByteChannel channel = Channels.newChannel(source
  				// .getInputStream());
  				// bb = ByteBuffer.allocateDirect(capacity);
  				// int read = 0;
  				// do {
  				// read = channel.read(bb);
  				// } while (read > 0);
  				// FIXME : use nio to parse the stream as it goes
  				bb = ByteBuffer.wrap(IOUtils.toByteArray(source
  						.getInputStream()));
  			} finally {
  				IOUtils.closeQuietly(fis);
  			}
  		}
  		CharBuffer cb = decoder.decode(bb);
  		for (Pattern pattern : patterns.keySet()) {
  			Matcher matcher = pattern.matcher(cb);
  			String output = matcher.replaceAll(patterns.get(pattern));
  			cb = CharBuffer.wrap(output);
  		}
  		// ByteBuffer bbout = encoder.encode(cb);
  		// ByteArrayOutputStream out = new ByteArrayOutputStream(capacity);
  		// WritableByteChannel wchannel = Channels.newChannel(out);
  		// wchannel.write(bbout);
  		ByteArrayResource res = new ByteArrayResource(cb.toString().getBytes());
  		return res;
 	}
 
 	public Class<?> getObjectType() {
 		return Resource.class;
 	}
 
 	public boolean isSingleton() {
 		return true;
 	}
 
 	public void afterPropertiesSet() throws Exception {
 		cs = Charset.forName(charset);
 		decoder = cs.newDecoder();
 		// encoder = cs.newEncoder();
 
 		for (String sedStr : filters) {
 			sedStr = sedStr.trim();
 			if (sedStr.length() < 4)
 				throw new SlcException(sedStr + " not properly formatted.");
 			if (sedStr.charAt(0) != 's')
 				throw new SlcException(sedStr + " not properly formatted.");
 			Character sep = sedStr.charAt(1);
 			List<String> tokens = new ArrayList<String>(4);
 			StringTokenizer st = new StringTokenizer(sedStr, sep.toString());
 			while (st.hasMoreTokens())
 				tokens.add(st.nextToken());
 			if (tokens.size() != 3 && tokens.size() != 4)
 				throw new SlcException(sedStr + " not properly formatted.");
 			patterns.put(Pattern.compile(tokens.get(1)), tokens.get(2));
 		}
 	}
 
 	public void setSource(Resource source) {
 		this.source = source;
 	}
 
 	public void setFilters(List<String> filters) {
 		this.filters = filters;
 	}
 
 	public void setCharset(String charset) {
 		this.charset = charset;
 	}
 
 }