/*
    * 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.File;
  import java.io.IOException;
  import java.security.Principal;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.jar.JarInputStream;
  import java.util.jar.JarOutputStream;
  
  import javax.servlet.http.HttpServletRequest;
  
  import org.apache.commons.io.filefilter.SuffixFileFilter;
  import org.apache.commons.lang.ArrayUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.seasar.tuigwaa.cms.ContentsService;
  import org.seasar.tuigwaa.cms.TgwResourceAlreadyExistsException;
  import org.seasar.tuigwaa.controller.ControllerService;
  import org.seasar.tuigwaa.database.BasicDatabaseService;
  import org.seasar.tuigwaa.logic.LogicService;
  import org.seasar.tuigwaa.model.ModelService;
  import org.seasar.tuigwaa.plugin.PluginService;
  import org.seasar.tuigwaa.security.Action;
  import org.seasar.tuigwaa.security.SecurityUtils;
  import org.seasar.tuigwaa.util.TgwContext;
  import org.seasar.tuigwaa.util.TgwPathResolver;
  
  import com.isenshi.util.ResourceUtils;
  import com.isenshi.util.extlib.DiconResource;
  
  /***
   * @author nishioka
   */
  public class SiteServiceImpl implements SiteService {
  
  	private List siteConfigs = new ArrayList();
  
  	private Map siteConfigMap = new HashMap();
  
  	private ControllerService controller;
  
  	private ModelService model;
  
  	private BasicDatabaseService db;
  
  	private ContentsService contents;
  
  	private LogicService logicService;
  
  	private PluginService pluginService;
  
  	private DesignService designService;
  
  	private ServiceHelper helper;
  
  	private Log log = LogFactory.getLog(getClass());
  
  	private String defaultInitpageName;
  
  	private String defaultMenupageName;
  
  	public SiteServiceImpl(ControllerService strutsService,
  			ModelService entityService, BasicDatabaseService dbService,
  			ContentsService contentsService, LogicService logicService,
  			PluginService pluginService, DesignService designService,
  			ServiceHelper helper) {
  		this.controller = strutsService;
  		this.model = entityService;
  		this.db = dbService;
  		this.contents = contentsService;
  		this.logicService = logicService;
  		this.pluginService = pluginService;
  		this.designService = designService;
  		this.helper = helper;
  	}
  
  	public void initSkins() {
  		designService.init();
 	}
 
 	public void createSite(SiteConfig siteConfig) {
 		doCreateSite(siteConfig, true);
 	}
 
 	public void deleteSite(String siteName) {
 		try {
 			contents.deleteSite(siteName);
 			model.deleteDomain(siteName);
 			ResourceUtils.deleteDirectory(TgwPathResolver
 					.getSiteDirectory(siteName));
 			deleteSiteLocalDirectory(siteName);
 
 			SiteConfig siteConfig = (SiteConfig) siteConfigMap.remove(siteName);
 			controller.deleteSite(siteName);
 			siteConfigs.remove(siteConfig);
 		} catch (Exception e) {
 			// should rollback
 			e.printStackTrace();
 		}
 	}
 
 	public void loadAllSites() {
 		db.loadExternalDatabase();
 		pluginService.loadPlugins();
 
 		String[] siteNames = getSiteNames();
 		if (siteNames == null) {
 			return;
 		}
 		for (int i = 0; i < siteNames.length; i++) {
 			loadSite(siteNames[i]);
 		}
 	}
 
 	public void loadSite(String siteName) {
 		String path = TgwPathResolver.getSiteConfigFilePath(siteName);
 		
 		DiconResource resource = new DiconResource();
 		resource.setPath(path);
 		resource.load();
 
 		if (resource.hasContainer()) {
 			SiteConfig siteConfig = (SiteConfig) resource
 					.getComponent(SiteConfig.class);
 			doCreateSite(siteConfig, false);
 			model.loadDomain(siteName);
 			helper.setupControllerConfigs(siteName);
 			logicService.loadLogics(siteName);
 			pluginService.loadExtPlugins(siteName);
 			helper.setupFileDataTable(siteName);
 		}
 	}
 
 	public void uploadSite(String siteName, JarInputStream jinput,
 			BackupDto backupDto) throws TgwServiceException {
 		ResourceUtils.readJar(jinput, Constants.DIRECTORY_APP);
 		loadSite(siteName);
 		restore(siteName, backupDto);
 
 		SiteConfig siteConfig = getSiteConfig(siteName);
 		siteConfig.setSkin(DesignService.ARCHIVE_SKIN_NAME);
 		saveSiteConfig(siteName);
 		
 		// あまりよくない。
 		// アップロード時のパスの更新の為におこなう
 		updatePath(siteConfig,true);
 	}
 
 	public void downloadSite(String siteName, JarOutputStream jarout,
 			BackupDto backupDto) throws TgwServiceException {
 		String path = TgwPathResolver.getSiteDirectory(siteName);
 
 		String backupDate = backupDto.getBackupDate();
 		if (backupDate == null || "".equals(backupDate)) {// needs full backup
 			backupDto.setType(BackupDto.BACKUPTYPE_FULL);
 			backup(siteName, backupDto);
 		}
 
 		String siteBackupDir = siteName + "/backup";
 		// backup without backup directory
 		ResourceUtils.writeJar(jarout, path, "", siteBackupDir);
 		// and then, backup date-specified backup directory
 		ResourceUtils.writeJar(jarout, path + "/" + Constants.DIRECTORY_BACKUP
 				+ backupDto.getBackupDate(), siteBackupDir, null);
 	}
 
 	public void setDefaultInitpageName(String defaultInitpageName) {
 		this.defaultInitpageName = defaultInitpageName;
 	}
 
 	public void setDefaultMenupageName(String defaultMenupageName) {
 		this.defaultMenupageName = defaultMenupageName;
 	}
 
 	// This method is called both at initialization of system and craetion of
 	// site
 	private void doCreateSite(SiteConfig siteConfig, boolean initialize) {
 
 		String siteName = siteConfig.getName();
 
 		try {
 			if (siteConfig.getInitPagename() == null
 					|| siteConfig.getInitPagename().equals("")) {
 				siteConfig.setInitPagename(defaultInitpageName);
 			}
 
 			if (siteConfig.getMenuPagename() == null
 					|| siteConfig.getMenuPagename().equals("")) {
 				siteConfig.setMenuPagename(defaultMenupageName);
 			}
 
 			try{
 				contents.createSite(siteConfig);
 			}catch(TgwResourceAlreadyExistsException e){
 				// アプリケーション立ち上げ時に、
 				// サイト作成時と同じ処理を実行しているものと
 				// 思われる。
 				// したがって既にサイトが存在する場合には、必ずここで
 				// エラーが発生する
 			}
 			controller.createSite(siteConfig);
 
 			if (!siteConfig.isUseBaseDatabase()) {
 				String dbName = siteConfig.getDbName();
 				String dbSchema = siteConfig.getDbSchema();
 				db.setExternalDatabaseMapping(siteName, dbName, dbSchema);
 			}
 			model.createDomain(siteName);
 
 			siteConfigMap.put(siteName, siteConfig);
 			siteConfigs.add(siteConfig);
 			if (initialize) {
 				initializeSite(siteConfig);								
 				doSave(siteConfig);
 			}
 			updatePath(siteConfig, false);
 			loadSecurity(siteConfig);
 
 		} catch (TgwServiceException e) {
 			// TODO rollback
 			e.printStackTrace();
 		} catch (Exception e) {
 			e.printStackTrace();
 			throw new RuntimeException(e);
 		}
 	}
 
 	public void editSite(SiteConfig siteConfig) {
 		initSecurity(siteConfig);
 		loadSecurity(siteConfig);
 
 		SiteConfig oldSiteConfig = (SiteConfig) siteConfigMap.get(siteConfig
 				.getName());		
 		
 		oldSiteConfig.copySiteConfig(siteConfig); // can't replace, so copy to
 		// oldsiteconfig
 		doSave(siteConfig);
 
 		try {
 			designService.sync(siteConfig, false);
 		} catch (TgwServiceException tse) {
 			tse.printStackTrace();
 			throw new RuntimeException(tse);
 		}
 	}
 
 	public void saveSiteConfig(String siteName) {
 		SiteConfig siteConfig = getSiteConfig(siteName);
 		doSave(siteConfig);
 	}
 
 	public List getSiteConfigList() {
 		return siteConfigs;
 	}
 
 	public SiteConfig getSiteConfig(String siteName) {
 		return (SiteConfig) siteConfigMap.get(siteName);
 	}
 
 	public void backup(String siteName, BackupDto backupDto)
 			throws TgwServiceException {
 
 		String dateStr = Constants.SIMPLE_DATEFORMAT.format(new Date());
 		backupDto.setBackupDate(dateStr);
 		String backupDirectory = TgwPathResolver.getSiteBackupDirPath(siteName,
 				dateStr);
 
 		try {
 			if (backupDto.isIncludeContents()) {
 				contents.backup(siteName, backupDirectory);
 			}
 
 			if (backupDto.isIncludeDatabase()) {
 				SiteConfig siteConfig = getSiteConfig(siteName);
 				if (!siteConfig.isUseBaseDatabase()) {
 					db.backup(siteConfig.getDbName(), siteConfig.getDbSchema(),
 							backupDto.getTablenames(), backupDirectory);
 				} else {
 					db.backup(null, siteName, backupDto.getTablenames(),
 							backupDirectory);
 				}
 			}
 
 			backupSiteLocalDirectory(siteName, backupDirectory);
 		} catch (Exception e) {
 			log.error("failed to backup : " + e.getMessage());
 			e.printStackTrace();
 			ResourceUtils.removeContent(backupDirectory);
 			throw new TgwServiceException(e);
 		}
 	}
 
 	public List getBackupDates(String siteName) {
 		String backupDirectory = TgwPathResolver.getSiteBackupDirPath(siteName);
 		String[] names = ResourceUtils.getChildrenNames(backupDirectory);
 		if (names == null || names.length == 0) {
 			return null;
 		}
 
 		List dates = new ArrayList();
 		for (int i = 0; i < names.length; i++) {
 			BackupDto dto = retrieveBackupDto(siteName, names[i]);
 			dates.add(dto);
 		}
 		return dates;
 	}
 
 	public void restore(String siteName, BackupDto backupDto)
 			throws TgwServiceException {
 
 		String backupDirectory = TgwPathResolver.getSiteBackupDirPath(siteName,
 				backupDto.getBackupDate());
 		if (backupDirectory.endsWith(Constants.DIRECTORY_BACKUP)) {
 			// At the restore, backupDto might not be set to indicate collect
 			// directory
 			String[] candidates = ResourceUtils
 					.getChildrenNames(backupDirectory);
 			if (candidates == null || candidates.length == 0) {
 				throw new TgwServiceException(
 						"No backup contents avaliable on local filesystem for restore.");
 			} else {
 				String candidate = candidates[candidates.length - 1];
 				backupDirectory = TgwPathResolver.getSiteBackupDirPath(
 						siteName, candidate);
 				backupDto.setBackupDate(candidate);
 			}
 		}
 
 		try {
 			// needs to retrieve backup type, here
 			setBackupType(backupDirectory, backupDto);
 
 			if (backupDto.isIncludeContents()) {
 				contents.restore(siteName, backupDirectory);
 			}
 
 			if (backupDto.isIncludeDatabase()) {
 				SiteConfig siteConfig = getSiteConfig(siteName);
 				if (!siteConfig.isUseBaseDatabase()) {
 					db.restore(siteConfig.getDbName(),
 							siteConfig.getDbSchema(), null, backupDirectory);
 				} else {
 					db.restore(null, siteName, null, backupDirectory);
 				}
 			}
 
 			if (!backupDto.isNone()) {
 				restoreSiteLocalDirectory(siteName, backupDirectory);
 			} else {
 				log
 						.warn("this archive doesn't include any valid backup data : "
 								+ backupDirectory);
 			}
 
 		} catch (Exception e) {
 			log.error("failed to restore contents under " + backupDirectory
 					+ " - " + e.getMessage());
 			throw new TgwServiceException(e);
 		}
 	}
 
 	public void deleteBackup(String siteName, BackupDto backupDto)
 			throws TgwServiceException {
 		String backupDirectory = TgwPathResolver.getSiteBackupDirPath(siteName,
 				backupDto.getBackupDate());
 		try {
 			ResourceUtils.removeContent(backupDirectory);
 		} catch (Exception e) {
 			throw new TgwServiceException(e);
 		}
 	}
 
 	// [Start] ----- Security -----
 
 	public void setSecurity(String siteName, Action action, String roles) {
 		SiteConfig siteConfig = getSiteConfig(siteName);
 		String[] roleNames = SecurityUtils.splitRoleNames(roles);
 		if (SecurityUtils.hasUnauthenticated(roleNames)) {
 			siteConfig.putActionRoles(action, null);
 		} else {
 			siteConfig.putActionRoles(action, roles);
 		}
 		setActionRoles(siteName, action, roleNames);
 	}
 
 	public boolean hasPermission(String siteName, String role, Action action) {
 		SiteConfig siteConfig = getSiteConfig(siteName);
 		String[] roleNames = siteConfig.getRoleNames(action);
 		if (roleNames == null || roleNames.length < 1) {
 			return true;
 		}
 		return ArrayUtils.contains(roleNames, role);
 	}
 
 	public boolean hasPermission(String siteName, HttpServletRequest request,
 			Action action) {
 		SiteConfig siteConfig = getSiteConfig(siteName);
 		String[] roleNames = siteConfig.getRoleNames(action);
 		if (roleNames == null || roleNames.length < 1) {
 			return true;
 		}
 		for (int i = 0; i < roleNames.length; i++) {
 			if (request.isUserInRole(roleNames[i])) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	public boolean hasPermission(String siteName, Principal principal,
 			Action action) {
 		throw new UnsupportedOperationException();
 	}
 
 	public void updatePath(SiteConfig siteConfig, boolean isNeedCleanup)
 			throws TgwServiceException {
 
 		String siteName = siteConfig.getName();
 		String path = "/top";
 
 		if (isNeedCleanup) {
 			String[] forwardNames = controller.getForwardNames(siteName, path);
 			for (int i = 0; i < forwardNames.length; i++) {
 				String forwardName = forwardNames[i];
 				if (forwardName.endsWith("html")) {
 					controller.removeForwardPath(siteName, path, forwardName,
 							"/" + forwardName);
 				}
 			}
 		}
 		
 		String[] skinPages = null;		
 		if("archive".equals(siteConfig.getSkin())){
 			String realPath = 
 				TgwContext.getRealPath(Constants.SITE_LOCAL_DIRECTORY + "/" + siteName);			
 			File siteDir = new File(realPath);
 			skinPages = siteDir.list(new SuffixFileFilter(".html"));						
 		}else{
 			DesignConfig designConfig = 
 				designService.getDesignConfig(siteConfig.getSkin());			
 			skinPages = designConfig.getAvailablePages();
 		}		
 		
 		if(skinPages != null){// アップロード時の最初の doCreateSite で発生
 			for (int i = 0; i < skinPages.length; i++) {
 				String skinHtml = skinPages[i];
 				try {
 					controller.addForwardPath(siteName, path, skinHtml, "/"
 							+ skinHtml);
 				} catch (TgwServiceException tse) {
 					log.warn("ignore " + skinHtml + " : " + tse.getMessage());
 				}
 			}			
 		}
 
 	}
 	
 	public void copySite(String srcSiteName, String destSiteName) throws TgwException{
 				
 		BackupDto dto = getDatabaseBackupDto();
 
 		try{			
 			// src backup for copying database data
 			backup(srcSiteName,dto);
 			
 			String siteRoot = TgwPathResolver.getSiteDirectory("");
 			String srcPath = ResourceUtils.getFile(siteRoot + "/" + srcSiteName).getAbsolutePath();
 			String destPath = ResourceUtils.getFile(siteRoot).getAbsolutePath() + File.separator + destSiteName;
 									
 			// copy site directory
 			ResourceUtils.copyDirectory(srcPath,destPath);
 		
 			// override siteConfig
 			SiteConfig siteConfig = new SiteConfig();
 			SiteConfig oldSiteConfig = (SiteConfig) siteConfigMap.get(srcSiteName);
 			copySiteConfig(oldSiteConfig,siteConfig);			
 			siteConfig.setName(destSiteName);
 			doSave(siteConfig);
 			
 			// override model.ecore
 			if(model.getDomain(srcSiteName) != null){
 				model.copyDomain(srcSiteName,destSiteName);				
 			}
 						
 			// initialize site/creation site local directory
 			initializeSite(siteConfig);
 												
 			// content copy
 			contents.copySite(srcSiteName,destSiteName);
 						
 			// load
 			loadSite(destSiteName);
 			
 			// dbrestore
 			restore(destSiteName,dto);			
 			
 			// restore site local
 			String backupDirectory = TgwPathResolver.getSiteBackupDirPath(destSiteName,dto.getBackupDate());
 			String srcSiteLocalPath = ResourceUtils.getFile(backupDirectory + "/" + srcSiteName).getPath();
 			String destSiteLocalPath = ResourceUtils.getFile(backupDirectory + "/" + destSiteName).getPath();
 			ResourceUtils.copyDirectory(srcSiteLocalPath,destSiteLocalPath);
 
 			restoreSiteLocalDirectory(destSiteName,backupDirectory);			
 			deleteBackup(destSiteName,dto);
 
 		}catch(Exception e){
 			throw new TgwException("ETGW4002",new Object[]{srcSiteName,destSiteName,e.getMessage()},e);
 		}		
 	}
 
 	// [Start] ----- Private Method -----
 
 	private String[] getSiteNames() {
 		return ResourceUtils.getChildrenNames(Constants.DIRECTORY_APP);
 	}
 
 	private void doSave(SiteConfig config) {
 		DiconResource resource = new DiconResource();
 		resource.addComponent(config);
 		resource.setPath(TgwPathResolver
 				.getSiteConfigFilePath(config.getName()));
 		resource.save();
 	}
 
 	private void loadSecurity(SiteConfig siteConfig) {
 		for (int i = 0; i < Action.ACTIONS.length; i++) {
 			Action action = Action.ACTIONS[i];
 			String[] roleNames = siteConfig.getRoleNames(action);
 			setActionRoles(siteConfig.getName(), action, roleNames);
 		}
 	}
 
 	private void initSecurity(SiteConfig siteConfig) {
 		if (!siteConfig.isSecurity()) {
 			return; // no security
 		}
 
 		String[] roleNames = siteConfig.getRoleNames();
 		boolean unauthencticatedFlag = SecurityUtils
 				.hasUnauthenticated(roleNames);
 		roleNames = SecurityUtils.removeUnauthenticated(roleNames);
 		String roles = StringUtils.join(roleNames, ",");
 
 		for (int i = 0; i < Action.ACTIONS.length; i++) {
 			Action action = Action.ACTIONS[i];
 			if (!action.equals(Action.PAGE_VIEW) || !unauthencticatedFlag) {
 				siteConfig.putActionRoles(action, roles);
 			}
 		}
 	}
 
 	private void setActionRoles(String siteName, Action action,
 			String[] roleNames) {
 		boolean unauthencticatedFlag = SecurityUtils
 				.hasUnauthenticated(roleNames);
 		String roles = null;
 
 		if ((roleNames != null && roleNames.length == 0)
 				|| unauthencticatedFlag) {
 			roles = "";
 		} else {
 			roleNames = SecurityUtils.removeUnauthenticated(roleNames);
 			roles = StringUtils.join(roleNames, ",");
 		}
 		controller.setActionRoles(siteName, action, roles);
 	}
 
 	private void createSiteLocalDirectory(String siteName) {
 		String urlpath = Constants.SITE_LOCAL_DIRECTORY + File.separator
 				+ siteName;
 		String siteLocal = TgwContext.getRealPath(urlpath);
 		if (ResourceUtils.createDirectory(siteLocal)) {
 			log.info("create site local directory : " + siteLocal);
 		}
 	}
 
 	private void backupSiteLocalDirectory(String siteName,
 			String backupDirectory) throws IOException {
 		String path = TgwContext.getRealPath("/"
 				+ Constants.SITE_LOCAL_DIRECTORY);
 		String srcPath = path + File.separator + siteName;
 		String destPath = ResourceUtils.getFile(backupDirectory).getPath();
 		ResourceUtils.copyFile(srcPath, destPath);
 	}
 
 	private void restoreSiteLocalDirectory(String siteName,
 			String backupDirectory) throws IOException {
 		String destPath = TgwContext.getRealPath("/"
 				+ Constants.SITE_LOCAL_DIRECTORY);
 		String srcPath = ResourceUtils
 				.getFile(backupDirectory + "/" + siteName).getPath();
 		ResourceUtils.copyFile(srcPath, destPath);
 	}
 
 	private void deleteSiteLocalDirectory(String siteName) {
 		String path = TgwContext.getRealPath("/"
 				+ Constants.SITE_LOCAL_DIRECTORY + "/" + siteName);
 		ResourceUtils.deleteDirectory(new File(path));
 	}
 
 	private BackupDto retrieveBackupDto(String siteName, String backupDate) {
 		String path = TgwPathResolver
 				.getSiteBackupDirPath(siteName, backupDate);
 		BackupDto dto = new BackupDto();
 		dto.setBackupDate(backupDate);
 		setBackupType(path, dto);
 		return dto;
 	}
 
 	private void setBackupType(String path, BackupDto dto) {
 
 		boolean isTableBackuped = ResourceUtils.isExist(path + "table.dicon");
 		boolean isPageBackuped = ResourceUtils.isExist(path + "webdav");
 
 		if (isTableBackuped && isPageBackuped) {
 			dto.setType(BackupDto.BACKUPTYPE_FULL);
 		} else if (isTableBackuped && !isPageBackuped) {
 			dto.setType(BackupDto.BACKUPTYPE_DATABASE);
 		} else if (!isTableBackuped && isPageBackuped) {
 			dto.setType(BackupDto.BACKUPTYPE_PAGE);
 		} else { // old archive and so on ...
 			dto.setType(BackupDto.BACKUPTYPE_NONE);
 		}
 	}
 	
 	private BackupDto getDatabaseBackupDto(){
 		BackupDto dto = new BackupDto();
 		dto.setType(BackupDto.BACKUPTYPE_DATABASE);
 		return dto;
 	}
 	
 	private void copySiteConfig(SiteConfig srcSiteConfig, SiteConfig destSiteConfig){
 		
 		destSiteConfig.setName(srcSiteConfig.getName());
 		destSiteConfig.setTitle(srcSiteConfig.getTitle());
 		destSiteConfig.setDescription(srcSiteConfig.getDescription());
 		destSiteConfig.setRoles(srcSiteConfig.getRoles());
 		destSiteConfig.setEasyMode(srcSiteConfig.isEasyMode());
 		destSiteConfig.setPageEditMode(srcSiteConfig.getPageEditMode());
 		destSiteConfig.setSkin(srcSiteConfig.getSkin());
 		destSiteConfig.setUseBaseDatabase(srcSiteConfig.isUseBaseDatabase());
 		destSiteConfig.setDbName(srcSiteConfig.getDbName());
 		destSiteConfig.setDbSchema(srcSiteConfig.getDbSchema());		
 		
 		Map map = srcSiteConfig.getActionRolesMap();
 		if(map != null){
 			for(Iterator i=map.keySet().iterator();i.hasNext();){
 				String actionName = (String)i.next();
 				destSiteConfig.putActionRoles(actionName,(String)map.get(actionName));
 			}
 		}
 	}
 	
 	private void initializeSite(SiteConfig siteConfig) throws TgwServiceException{
 		
 		String siteName = siteConfig.getName();		
 		createSiteLocalDirectory(siteName);
 		if (!siteConfig.isUseBaseDatabase()) {
 			List list = model.readDatabase(siteName);
 			controller.addEntityConfigs(list);
 		}
 		designService.sync(siteConfig,false);				
 		initSecurity(siteConfig);
 	}
 
 }