/*
    * Copyright 2004-2006 the Seasar Foundation and the Others.
    *
    * 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.seasar.tuigwaa.system;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  import java.util.zip.ZipOutputStream;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.seasar.tuigwaa.cms.ContentsStoreService;
  import org.seasar.tuigwaa.cms.core.Resource;
  import org.seasar.tuigwaa.util.MimeMappings;
  import org.seasar.tuigwaa.util.TgwUtils;
  
  import com.isenshi.util.PathUtils;
  import com.isenshi.util.ResourceUtils;
  
  /***
   * @author someda
   */
  public class DesignServiceImpl implements DesignService {
  	
  	private static final String SKIN_TEMPLATE_DIR = "template/skin";
  	private static final String SKIN_DIR = ".SKINS";
  	
  	private static final String SYSTEM_SKINPAGE_NAME = "page.html";	
  	private static final String[] SYSTEM_AVAILABLE_PAGES = {SYSTEM_SKINPAGE_NAME};
  		
  	private ContentsStoreService storeService;
  	
  	private Log log = LogFactory.getLog(getClass());
  	
  	public DesignServiceImpl(ContentsStoreService storeService){
  		this.storeService = storeService;		
  	}
  	
  	public void init(){
  		File skinTemplateDir = ResourceUtils.getFile(SKIN_TEMPLATE_DIR);		
  		Resource resource = null;				
  		try{
  			resource=storeService.getResource(SKIN_DIR,SYSTEM_SKIN_NAME);
  		}catch(TgwSecurityException tse){
  			// should not be occurred, because this methods run by admin user
  		}
  		
  		boolean copyFlag = false;		
  		if(resource != null){
  			Date lastModifiedDate = resource.getModificationDateAsDate();						
  			File[] templates = skinTemplateDir.listFiles();
  			for(int i=0;i<templates.length;i++){			
  				if(SYSTEM_SKIN_NAME.equals(templates[i].getName())){				
  					if(FileUtils.isFileNewer(templates[i],lastModifiedDate)){
  						copyFlag = true;
  					}
  					break;
  				}
  			}
  		}else{
  			copyFlag = true;
  		}
  		
  		if(copyFlag){
  			log.warn("skin template resources are newer than WEB-DAV ones, starting to copy.");
  			try {
  				storeService.copyFromFileSystem(skinTemplateDir, SKIN_DIR);
  			} catch (Exception e) {
  				e.printStackTrace();
  			}
  		}
  	}
  			
  	public String[] getAllSkinNames() {
  		String skinNames[] = null;
  		try {
  			List list = storeService.getFolderList(SKIN_DIR, "");			
 			skinNames = new String[list.size()];
 			Iterator itr = list.iterator();
 			for (int i = 0; itr.hasNext(); i++) {
 				Resource resource = (Resource) itr.next();
 				if(resource.isFolder()){
 					// need-to-validate 
 					skinNames[i] = resource.getPageName();					
 				}
 			}
 		} catch (Exception e) {
 			log.error("failed to load skin names : " + e.getMessage());
 		}		
 		return skinNames;		
 	}
 	
 	public String[] getAvailableSkinNames(String siteName) {
 		return getAllSkinNames(); // tempolary
 	}	
 
 	public void uploadSkin(String skinName, ZipInputStream zipInput) throws TgwServiceException {
 
 		boolean isValid = false;
 		ByteArrayOutputStream baos = null;
 		ByteArrayInputStream bais = null;
 		
 		try{			
 			storeService.createFolder(SKIN_DIR,skinName);
 			
 			ZipEntry entry = null; 
 			String root = null;
 			while((entry = zipInput.getNextEntry())!= null){				
 				String name = entry.getName();
 				if(root == null || !"".equals(root)){
 					root = PathUtils.getRootPath(name);
 				}
 				String relative = PathUtils.getRelativePath(root,name);
 				String uri = skinName + "/" + relative;				
 				if(entry.isDirectory()){
 					storeService.createFolder(SKIN_DIR,uri);					
 				}else{					
 					baos = new ByteArrayOutputStream();
 					int length = 0;
 					int contentLength = 0;
 					int bufsize = 1024;
 					byte[] buf = new byte[bufsize];
 					while(zipInput.available() > 0 && ((length = zipInput.read(buf,0,bufsize)) != -1)){
 						baos.write(buf,0,length);
 						contentLength += length;
 					}					
 					bais = new ByteArrayInputStream(baos.toByteArray());
 					
 					String extension = PathUtils.getExtension(uri);
 					String contentType = MimeMappings.getContentType(extension);
 					storeService.createResource(SKIN_DIR,uri,contentType,contentLength,bais);
 					
 					baos.close();
 					bais.close();
 				}				
 			}						
 			if(!(isValid = validate(skinName))){ // roll-back
 				throw new TgwServiceException("invalid upload contents for skin : " + skinName);
 			}			
 		}catch(IOException ioe){
 			log.error("failed to read input stream : " + ioe.getMessage());
 		}catch(IllegalArgumentException iae){ // in-case Japanese name
 			log.error("archive including file with Japanese name not allowed.");
 			throw new TgwServiceException("archive including file with Japanese name not allowed.");
 		}catch(Exception e){
 			log.error(e.getMessage());
 			throw new TgwServiceException(e);
 		}finally{			
 			IOUtils.closeQuietly(baos);
 			IOUtils.closeQuietly(bais);			
 			if(!isValid){
 				log.error("invalid upload skin : " + skinName);
 				storeService.delete(SKIN_DIR,skinName);
 			}
 		}
 	}
 	
 	public void downloadSkin(String skinName, ZipOutputStream zipOutput) throws TgwServiceException {
 		
 		try{			
 			List resourceList = storeService.getRecursivePageOrFolderList(SKIN_DIR,skinName);
 			for(Iterator i=resourceList.iterator();i.hasNext();){
 				Resource resource = (Resource) i.next();
 				String path = resource.getPath();
 				zipOutput.putNextEntry(new ZipEntry(path));				
 				if(!resource.isFolder()){
 					storeService.writeResource(SKIN_DIR,path,zipOutput);
 				}							
 			}
 		}catch(IOException ioe){
 			log.error("failed to write output stream : " + ioe.getMessage());
 		}catch(Exception e){
 			log.error(e.getMessage());
 			throw new TgwServiceException(e);
 		}		
 	}	
 
 	public void deleteSkin(String skinName, List configList) throws TgwServiceException {
 		
 		if(SYSTEM_SKIN_NAME.equals(skinName)){
 			throw new TgwServiceException("system default skins (" + skinName + ") cannot be deleted.");
 		}
 		
 		for(Iterator i=configList.iterator();i.hasNext();){
 			SiteConfig siteConfig = (SiteConfig) i.next();
 			if(skinName.equals(siteConfig.getSkin())){
 				throw new TgwServiceException("skin (" + skinName + ") being used for site : " + siteConfig.getName());
 			}
 		}		
 		
 		try{
 			storeService.delete(SKIN_DIR,skinName);
 		}catch(Exception e){
 			throw new TgwServiceException(e);
 		}
 	}
 
 	public void sync(SiteConfig siteConfig, boolean overwrite) throws TgwServiceException {
 		
 		String siteName = siteConfig.getName();
 		String skinName = siteConfig.getSkin();
 
 		String siteRootPath = TgwUtils.getTuigwaaActionServlet()
 		.getServletConfig().getServletContext().getRealPath(siteName);		
 		File siteRoot = new File(siteRootPath);
 		
 		if(!siteRoot.exists()){
 			siteRoot.mkdir();
 		}else if(!overwrite){
 			try{
 				FileUtils.cleanDirectory(siteRoot);
 			}catch(IOException ioe){// do-nothing				
 			}
 		}
 		
 		try{
 			if(skinName.equals(ARCHIVE_SKIN_NAME)){ // Archive Skin
 				
 			}else{ // Web-DAV skin, needs version check ?
 				storeService.copyToFileSystem(SKIN_DIR,skinName,siteRoot);
 			}
 		}catch(Exception e){
 			log.error("failed to sync resources : " + e.getMessage());
 		}
 	}
 	
 
 	public boolean validate(String skinName){
 		
 		boolean flag = false;
 		// skin contains page.html
 		String uri = skinName + "/" + SYSTEM_SKINPAGE_NAME;
 		try{
 			flag = storeService.isExistResource(SKIN_DIR,uri,true);
 		}catch(TgwSecurityException tse){
 			// do-nothing
 			tse.printStackTrace();
 		}
 		return flag;
 	}
 	
 	public void saveConfig(DesignConfig designConfig) throws TgwServiceException{
 		//FIXME: need to implements		
 	}
 	
 	public DesignConfig getDesignConfig(String skinName){
 		
 		DesignConfig designConfig = new DesignConfig();
 		designConfig.setName(skinName);
 		
 		try{
 			List list = storeService.getPageList(SKIN_DIR,skinName);
 			List availablePageList = new ArrayList();
 			for(Iterator i=list.iterator();i.hasNext();){
 				Resource resource = (Resource)i.next();				
 				String pagePath = resource.getPageName();				
 				if(resource.isFile() && pagePath.endsWith("html")){					
 					availablePageList.add(resource.getPageName());						
 				}
 			}
 			int size = availablePageList.size();			
 			String[] availablePages;
 			if(size == 0){
 				availablePages = SYSTEM_AVAILABLE_PAGES;
 			}else{
 				availablePages = (String[])availablePageList.toArray(new String[size]);
 			}			
 			designConfig.setAvailablePages(availablePages);			
 		}catch(Exception e){
 			designConfig.setAvailablePages(SYSTEM_AVAILABLE_PAGES);
 		}
 						
 		return designConfig;
 	}
 	// ----- [private methods ] -----
 	
 	
 }