package com.bosshand.virgo.file.service;

import com.bosshand.virgo.exception.ServiceException;
import com.bosshand.virgo.file.dao.*;
import com.bosshand.virgo.file.model.*;
import com.bosshand.virgo.file.util.AliyunOSSUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

@Service
public class FileNodeManagerService {
	
	@Autowired
	private FileNodeProjectModelDao fileNodeProjectModelDao;
	
	@Autowired
	private FileNodeProjectDao fileNodeProjectDao;
	
	@Autowired
	private FileNodeOrganizationModelDao fileNodeOrganizationModelDao;
	
	@Autowired
	private FileNodeOrganizationDao fileNodeOrganizationDao;
	
	@Autowired
	private FielNodeProjectSetPermissionsDao fielNodeProjectSetPermissionsDao;
	
	@Autowired
	private FileNodeUserSetPermissionsDao fileNodeUserSetPermissionsDao;
	
	//*****************************************************************
	// FileNodeOrganization
	//*****************************************************************

	public List<FileNodeOrganization> organizationFolder(Long[] ids) {
		return fileNodeOrganizationDao.organizationFolder(ids);
	}
	
	public List<FileNodeOrganization> generateFileNodeOrganization(int projectId, int organizationId, int organizationTypeId) {
		
		List<FileNodeOrganization> nodes = fileNodeOrganizationDao.list(FileNodeOrganization.ROOT_ID, projectId, organizationId);
		
		if (nodes.size() > 0) {
			return nodes;
		}
		
		List<FileNodeOrganizationModel> list = fileNodeOrganizationModelDao.listByOrganizationTypeId(organizationTypeId);
		for (FileNodeOrganizationModel model : list) {
			if (model.getParentId() == FileNodeOrganization.ROOT_ID) {
				FileNodeOrganization fileNodeOrganization = new FileNodeOrganization(model.getParentId(), model.getName(), model.isDirectory(), model.getNode(), projectId, organizationId, model.getPermissions());
				fileNodeOrganizationDao.insert(fileNodeOrganization);
				saveList(model.getId(), fileNodeOrganization.getId(), projectId, organizationId, list);
			}
		}
		
		return fileNodeOrganizationDao.list(FileNodeOrganization.ROOT_ID, projectId, organizationId);
	}

	private void saveList(int parentId, int fileNodeOrganizationId, int projectId, int organizationId, List<FileNodeOrganizationModel> slist) {
		List<FileNodeOrganizationModel> list = new ArrayList<>();
		for (FileNodeOrganizationModel s : slist) {
			if (s.getParentId() == parentId) {
				list.add(s);
			}
		}
		if (list.size() > 0) {
			for (FileNodeOrganizationModel model : list) {
				FileNodeOrganization fileNodeOrganization = new FileNodeOrganization(fileNodeOrganizationId, model.getName(), model.isDirectory(), model.getNode(), projectId, organizationId, model.getPermissions());
				fileNodeOrganizationDao.insert(fileNodeOrganization);
				saveList(model.getId(), fileNodeOrganization.getId(), projectId, organizationId, slist);
			}
		}
	}

	public FileNodeOrganization getFileNodeOrganization(int id) throws ServiceException {
		return fileNodeOrganizationDao.get(id);
	}

	public byte[] getFileNodeOrganizationNode(int id) {
		FileNodeOrganization fileNodeOrganization = fileNodeOrganizationDao.get(id);
		return AliyunOSSUtil.getByte(fileNodeOrganization.getNode());
	}

	public FileNodeOrganization createFileNodeOrganization(InputStream is, String name, int parentId) throws ServiceException {
		if (parentId != FileNodeOrganization.ROOT_ID) {
			FileNodeOrganization parentNode = getFileNodeOrganization(parentId);
			if (parentNode == null || !parentNode.isDirectory()) {
				throw new ServiceException("Incorrect parent");
			}
		}
		FileNodeOrganization fileInfo = new FileNodeOrganization();
		fileInfo.setName(name);
		fileInfo.setParentId(parentId);
		fileInfo.setDirectory(false);
		fileInfo.setNode(AliyunOSSUtil.upload(is));
		fileNodeOrganizationDao.insert(fileInfo);
		return fileInfo;
	}

	public FileNodeOrganization createDirFileNodeOrganization(FileNodeOrganization fileNode, int parentId) throws ServiceException {
		if (parentId != FileNodeOrganization.ROOT_ID) {
			FileNodeOrganization parentNode = getFileNodeOrganization(parentId);
			if (parentNode == null || !parentNode.isDirectory()) {
				throw new ServiceException("Incorrect parent");
			}
		}
		fileNode.setDirectory(true);
		fileNode.setParentId(parentId);
		fileNodeOrganizationDao.insert(fileNode);
		return fileNode;
	}

	public void deleteFileNodeOrganization(int id) throws ServiceException {
		FileNodeOrganization node = fileNodeOrganizationDao.get(id);
		if (node == null) {
			throw new ServiceException("node not found");
		}
		if (node.isDirectory()) {
			throw new ServiceException("node is a directory");
		}
		AliyunOSSUtil.delete(node.getNode());
		fileNodeOrganizationDao.remove(id);
	}

	public void deleteDirFileNodeOrganization(int id) throws ServiceException {
		FileNodeOrganization node = fileNodeOrganizationDao.get(id);
		if (node == null) {
			throw new ServiceException("node not found");
		}
		if (node.isDirectory()) {
			fileNodeOrganizationDao.remove(id);
		} else {
			deleteFileNodeOrganization(id);
		}
	}

	public void updateFileNodeOrganization(FileNodeOrganization fileNode) {
		fileNodeOrganizationDao.update(fileNode);
	}
	
	public List<FileNodeOrganization> listOrganization(int parentId) {
		return fileNodeOrganizationDao.listByParentId(parentId);
	}
	
	public boolean validationPasswordFileNodeOrganization(int id, String password) {
		FileNodeOrganization validationPassword = fileNodeOrganizationDao.validationPassword(id, password);
		if (validationPassword != null) {
			return true;
		}
		return false;
	}
	
	//*****************************************************************
	// FileNodeProject
	//*****************************************************************

	public List<FileNodeProject> projectFolder(Long[] ids) {
		return fileNodeProjectDao.projectFolder(ids);
	}
	
	public List<FileNodeProject> generateFileNodeProject(int projectId) {
		
		List<FileNodeProject> nodes = fileNodeProjectDao.list(FileNodeProject.ROOT_ID, projectId);
		
		if (nodes.size() > 0) {
			return nodes;
		}
		
		List<FileNodeProjectModel> list = fileNodeProjectModelDao.listAll();
		for (FileNodeProjectModel model : list) {
			if (model.getParentId() == FileNodeProject.ROOT_ID) {
				FileNodeProject fileNodeProject = new FileNodeProject(model.getParentId(), model.getName(), model.isDirectory(), model.getNode(), projectId, model.getPermissions());
				fileNodeProjectDao.insert(fileNodeProject);
				saveProjectList(model.getId(), fileNodeProject.getId(), projectId, list);
			}
		}
		
		return fileNodeProjectDao.list(FileNodeProject.ROOT_ID, projectId);
	}

	private void saveProjectList(int parentId, int fileNodeProjectId, int projectId, List<FileNodeProjectModel> slist) {
		List<FileNodeProjectModel> list = new ArrayList<>();
		for (FileNodeProjectModel s : slist) {
			if (s.getParentId() == parentId) {
				list.add(s);
			}
		}
		if (list.size() > 0) {
			for (FileNodeProjectModel model : list) {
				FileNodeProject fileNodeProject = new FileNodeProject(fileNodeProjectId, model.getName(), model.isDirectory(), model.getNode(), projectId, model.getPermissions());
				fileNodeProjectDao.insert(fileNodeProject);
				saveProjectList(model.getId(), fileNodeProject.getId(), projectId, slist);
			}
		}
	}

	public FileNodeProject getFileNodeProject(int id) throws ServiceException {
		return fileNodeProjectDao.get(id);
	}

	public byte[] getFileNodeProjectNode(int id) {
		FileNodeProject fileNodeProject = fileNodeProjectDao.get(id);
		return AliyunOSSUtil.getByte(fileNodeProject.getNode());
	}

	public FileNodeProject createFileNodeProject(InputStream is, String name, int parentId) throws ServiceException {
		if (parentId != FileNodeProject.ROOT_ID) {
			FileNodeProject parentNode = getFileNodeProject(parentId);
			if (parentNode == null || !parentNode.isDirectory()) {
				throw new ServiceException("Incorrect parent");
			}
		}
		FileNodeProject fileInfo = new FileNodeProject();
		fileInfo.setName(name);
		fileInfo.setParentId(parentId);
		fileInfo.setDirectory(false);
		fileInfo.setNode(AliyunOSSUtil.upload(is));
		fileNodeProjectDao.insert(fileInfo);
		return fileInfo;
	}

	public FileNodeProject createDirFileNodeProject(FileNodeProject fileNode, int parentId) throws ServiceException {
		if (parentId != FileNodeProject.ROOT_ID) {
			FileNodeProject parentNode = getFileNodeProject(parentId);
			if (parentNode == null || !parentNode.isDirectory()) {
				throw new ServiceException("Incorrect parent");
			}
		}
		fileNode.setDirectory(true);
		fileNode.setParentId(parentId);
		fileNodeProjectDao.insert(fileNode);
		return fileNode;
	}

	public void deleteFileNodeProject(int id) throws ServiceException {
		FileNodeProject node = fileNodeProjectDao.get(id);
		if (node == null) {
			throw new ServiceException("node not found");
		}
		if (node.isDirectory()) {
			throw new ServiceException("node is a directory");
		}
		AliyunOSSUtil.delete(node.getNode());
		fileNodeProjectDao.remove(id);
	}

	public void deleteDirFileNodeProject(int id) throws ServiceException {
		FileNodeProject node = fileNodeProjectDao.get(id);
		if (node == null) {
			throw new ServiceException("node not found");
		}
		if (node.isDirectory()) {
			fileNodeProjectDao.remove(id);
		} else {
			deleteFileNodeOrganization(id);
		}
	}

	public void updateFileNodeProject(FileNodeProject fileNode) {
		fileNodeProjectDao.update(fileNode);
	}

	public List<FileNodeProject> listProject(int parentId) {
		return fileNodeProjectDao.listByParentId(parentId);
	}
	
	//*****************************************************************
	// SetPermissions
	//*****************************************************************

	public void setPermissions(FielNodeProjectSetPermissions permissions) {
		fielNodeProjectSetPermissionsDao.insert(permissions);
	}

	public void updatePermissions(FielNodeProjectSetPermissions permissions) {
		fielNodeProjectSetPermissionsDao.update(permissions);
	}

	public FielNodeProjectSetPermissions getPermissions(int fileNodeProjectId, int organizationId) {
		FielNodeProjectSetPermissions permissions = fielNodeProjectSetPermissionsDao.getPermissions(fileNodeProjectId, organizationId);
		if (permissions != null) {
			permissions.setPassword(null);
		}
		return permissions;
	}
	
	public boolean validationPassword(int id, String password) {
		FielNodeProjectSetPermissions validationPassword = fielNodeProjectSetPermissionsDao.validationPassword(id, password);
		if (validationPassword != null) {
			return true;
		}
		return false;
	}

	public FielNodeProjectSetPermissions showPassword(int fileNodeProjectId, int organizationId) {
		return fielNodeProjectSetPermissionsDao.getPermissions(fileNodeProjectId, organizationId);
	}

	
	//*****************************************************************
	// SetUserPermissions
	//*****************************************************************
	
	public void setUserPermissions(FileNodeUserSetPermissions permissions) {
		fileNodeUserSetPermissionsDao.insert(permissions);
	}

	public void updateUserPermissions(FileNodeUserSetPermissions permissions) {
		fileNodeUserSetPermissionsDao.update(permissions);
	}

	public FileNodeUserSetPermissions getUserOrganizationPermissions(int fileNodeOrganizationId,int userId) {
		return fileNodeUserSetPermissionsDao.getOrganizationPermissions(fileNodeOrganizationId, userId);
	}
	
	public FileNodeUserSetPermissions getUserProjectPermissions(int fileNodeProjectId,int userId) {
		return fileNodeUserSetPermissionsDao.getProjectPermissions(fileNodeProjectId, userId);
	}

}