package siprp.medicina.processo.ui;

import static siprp.medicina.processo.logic.MedicinaProcessoLogic.APAGAR_CONSULTA;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.APAGAR_CONSULTA_MARCACAO;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.APAGAR_EXAME_MARCACAO;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.APAGAR_PROCESSO;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_CONSULTA;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_CONSULTA_MARCACAO;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_CONSULTA_MARCACAO_EMAIL;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_CONSULTA_MARCACAO_OBSERVACOES;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_EXAME;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_EXAME_MARCACAO;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_EXAME_MARCACAO_EMAIL;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_EXAME_MARCACAO_OBSERVACOES;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_FICHA;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.CREATE_PROCESSO;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.LOAD_TRABALHADOR;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.REFRESH;
import static siprp.medicina.processo.logic.MedicinaProcessoLogic.SELECT_TREE_NODE;
import info.clearthought.layout.TableLayout;
import info.clearthought.layout.TableLayoutConstraints;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.swing.BorderFactory;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import leaf.ui.LeafWindow;
import leaf.ui.LeafLogic.LeafUIActionBinding;
import leaf.ui.LeafWindow.ActionActivation;
import siprp.data.outer.TrabalhadoresConsultasData;
import siprp.data.outer.TrabalhadoresConsultasDatasData;
import siprp.data.outer.TrabalhadoresConsultasDatasEmailsData;
import siprp.data.outer.TrabalhadoresConsultasDatasObservacoesData;
import siprp.data.outer.TrabalhadoresData;
import siprp.data.outer.TrabalhadoresEcdsData;
import siprp.data.outer.TrabalhadoresEcdsDatasData;
import siprp.data.outer.TrabalhadoresEcdsDatasEmailsData;
import siprp.data.outer.TrabalhadoresEcdsDatasObservacoesData;
import siprp.data.outer.TrabalhadoresFichasAptidaoData;
import siprp.data.outer.TrabalhadoresProcessoData;
import siprp.medicina.processo.ProcessoDataProvider;
import siprp.medicina.processo.estrutura.ConsultaMutableTreeNode;
import siprp.medicina.processo.estrutura.DataMutableTreeNode;
import siprp.medicina.processo.estrutura.ECDsMutableTreeNode;
import siprp.medicina.processo.estrutura.EstruturaProcessoRenderer;
import siprp.medicina.processo.estrutura.FichaAptidaoMutableTreeNode;
import siprp.medicina.processo.estrutura.MailMutableTreeNode;
import siprp.medicina.processo.estrutura.ObservacoesMutableTreeNode;
import siprp.medicina.processo.estrutura.ProcessoMutableTreeNode;
import siprp.medicina.processo.estrutura.TrabalhadorMutableTreeNode;

import com.evolute.entity.evo.EvoDataObject;

public class ProcessoTreePanel extends JPanel
{
	private static final long serialVersionUID = 1L;

	private final LeafWindow parentWindow;

	private final JScrollPane mainScroll = new JScrollPane();;

	protected TrabalhadorMutableTreeNode rootNode;

	private final Map<EvoDataObject, DefaultMutableTreeNode> nodeByObject = new HashMap<EvoDataObject, DefaultMutableTreeNode>();

	@ActionActivation(onSelect = SELECT_TREE_NODE, onChange = "")
	public JTree mainTree;

	protected ProcessoDataProvider provider;

	public ProcessoTreePanel(LeafWindow parentWindow)
	{
		super();
		this.parentWindow = parentWindow;
		try
		{
			provider = ProcessoDataProvider.getProvider();

		} catch( Exception e )
		{
			provider = null;
			e.printStackTrace();
		}
		setupLayout();
		setupComponents();
		placeComponents();
	}

	private void setupLayout()
	{
		double[] cols = new double[] {
			TableLayout.FILL
		};
		double[] rows = new double[] {
			TableLayout.FILL
		};
		TableLayout layout = new TableLayout( cols, rows );
		this.setLayout( layout );
	}

	private void setupComponents()
	{
		this.setBorder( BorderFactory.createTitledBorder( BorderFactory.createEtchedBorder(), "Processos" ) );
		mainScroll.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED );
		mainScroll.setHorizontalScrollBarPolicy( JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED );
		rootNode = new TrabalhadorMutableTreeNode( "" );
		mainTree = new JTree( rootNode );
		mainTree.setExpandsSelectedPaths( true );
		mainTree.setCellRenderer( new EstruturaProcessoRenderer() );
		mainScroll.setViewportView( mainTree );
	}

	private void placeComponents()
	{
		this.add( mainScroll, new TableLayoutConstraints( 0, 0 ) );
	}

	@LeafUIActionBinding(action = LOAD_TRABALHADOR)
	public void setTrabalhador( TrabalhadoresData trabalhador )
	{
		clear();
		if( trabalhador == null )
		{
			return;
		}
		rootNode.setUserObject( trabalhador );
		List<DefaultMutableTreeNode> nodes = loadProcessos( trabalhador );
		for( DefaultMutableTreeNode node : nodes )
		{
			addNodeTo( node, rootNode );
		}
		((DefaultTreeModel) mainTree.getModel()).nodeStructureChanged( rootNode );
		int count = mainTree.getRowCount();
		for( int n = count - 1; n >= 0; n-- )
		{
			mainTree.expandRow( n );
		}
	}

	@LeafUIActionBinding(action = CREATE_PROCESSO)
	public void createProcessoNode( TrabalhadoresProcessoData processo )
	{
		if( processo != null )
		{
			ProcessoMutableTreeNode node = new ProcessoMutableTreeNode( processo );
			addAndRefresh( node, rootNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_FICHA)
	public void createFichaNode()
	{
		// if( ficha != null )
		// {
		// FichaAptidaoMutableTreeNode node = new FichaAptidaoMutableTreeNode(
		// ficha );
		// DefaultMutableTreeNode parentNode = nodeByObject.get(
		// ficha.getToTrabalhadoresProcesso() );
		// addAndRefresh( node, parentNode );
		// }
	}

	@LeafUIActionBinding(action = APAGAR_PROCESSO)
	public void apagarProcessoNode( TrabalhadoresProcessoData processo )
	{
		if( processo != null )
		{
			for( int i = 0; i < rootNode.getChildCount(); ++i )
			{
				DefaultMutableTreeNode node = (DefaultMutableTreeNode) rootNode.getChildAt( i );

				if( processo.equals( node.getUserObject() ) )
				{
					removeNode( node );
					break;
				}
			}
		}
	}

	@LeafUIActionBinding(action = APAGAR_CONSULTA)
	public void apagarConsultaNode( TrabalhadoresConsultasData consulta )
	{
		if( consulta != null )
		{
			DefaultMutableTreeNode node = nodeByObject.get( consulta );
			if( node != null )
			{
				removeNode( node );
			}
		}
	}

	@LeafUIActionBinding(action = APAGAR_CONSULTA_MARCACAO)
	public void apagarConsultaMarcacaoNode( TrabalhadoresConsultasDatasData consulta )
	{
		if( consulta != null )
		{
			DefaultMutableTreeNode node = nodeByObject.get( consulta );
			if( node != null )
			{
				removeNode( node );
			}
		}
	}
	
	@LeafUIActionBinding(action = APAGAR_EXAME_MARCACAO)
	public void apagarExameMarcacaoNode( TrabalhadoresEcdsDatasData exame )
	{
		if( exame != null )
		{
			DefaultMutableTreeNode node = nodeByObject.get( exame );
			if( node != null )
			{
				removeNode( node );
			}
		}
	}

	@LeafUIActionBinding(action = CREATE_CONSULTA)
	public void createConsultaNode( TrabalhadoresConsultasData consulta )
	{
		if( consulta != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( consulta.toProcesso_id() );
			ConsultaMutableTreeNode node = new ConsultaMutableTreeNode( consulta );
			node.setData( consulta.getData() );
			addAndRefresh( node, parentNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_CONSULTA_MARCACAO)
	public void createConsultaMarcacaoNode( TrabalhadoresConsultasDatasData marcacao )
	{
		if( marcacao != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( marcacao.toTrabalhadores_consultas_id() );
			DataMutableTreeNode node = new DataMutableTreeNode( marcacao );
			addAndRefresh( node, parentNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_CONSULTA_MARCACAO_EMAIL)
	public void createConsultaMarcacaoEmailNode( TrabalhadoresConsultasDatasEmailsData email )
	{
		if( email != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( email.toTrabalhadores_consultas_datas_id() );
			MailMutableTreeNode node = new MailMutableTreeNode( email );
			addAndRefresh( node, parentNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_CONSULTA_MARCACAO_OBSERVACOES)
	public void createConsultaMarcacaoObservacoesNode( TrabalhadoresConsultasDatasObservacoesData observacoes )
	{
		if( observacoes != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( observacoes.toTrabalhadores_consultas_datas_id() );
			ObservacoesMutableTreeNode node = new ObservacoesMutableTreeNode( observacoes );
			addNodeTo( node, parentNode );
			((DefaultTreeModel) mainTree.getModel()).nodeStructureChanged( parentNode );
			mainTree.setSelectionPath( new TreePath( node.getPath() ) );
		}
	}

	@LeafUIActionBinding(action = CREATE_EXAME)
	public void createExameNode( TrabalhadoresEcdsData exame )
	{
		if( exame != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( exame.toProcesso_id() );
			ECDsMutableTreeNode node = new ECDsMutableTreeNode( exame );
			node.setData( exame.getData() );
			addAndRefresh( node, parentNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_EXAME_MARCACAO)
	public void createExameMarcacaoNode( TrabalhadoresEcdsDatasData marcacao )
	{
		if( marcacao != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( marcacao.toTrabalhadores_ecds_id() );
			DataMutableTreeNode node = new DataMutableTreeNode( marcacao );
			addAndRefresh( node, parentNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_EXAME_MARCACAO_EMAIL)
	public void createExameMarcacaoEmailNode( TrabalhadoresEcdsDatasEmailsData email )
	{
		if( email != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( email.toTrabalhadores_ecds_datas_id() );
			MailMutableTreeNode node = new MailMutableTreeNode( email );
			addAndRefresh( node, parentNode );
		}
	}

	@LeafUIActionBinding(action = CREATE_EXAME_MARCACAO_OBSERVACOES)
	public void createConsultaMarcacaoObservacoesNode( TrabalhadoresEcdsDatasObservacoesData observacoes )
	{
		if( observacoes != null )
		{
			DefaultMutableTreeNode parentNode = nodeByObject.get( observacoes.toTrabalhadores_ecds_datas_id() );
			ObservacoesMutableTreeNode node = new ObservacoesMutableTreeNode( observacoes );
			addNodeTo( node, parentNode );
			((DefaultTreeModel) mainTree.getModel()).nodeStructureChanged( parentNode );
			mainTree.setSelectionPath( new TreePath( node.getPath() ) );
		}
	}

	@LeafUIActionBinding(action = REFRESH)
	public void refresh()
	{
		DefaultMutableTreeNode selected = getSelectedNode();
		if( selected != null )
		{
			// ((DefaultTreeModel) mainTree.getModel()).nodeStructureChanged(
			// rootNode );
			mainTree.setSelectionPath( new TreePath( rootNode.getPath() ) );
			mainTree.setSelectionPath( new TreePath( selected.getPath() ) );
		}
		revalidate();
		repaint();
	}

	protected List<DefaultMutableTreeNode> loadProcessos( TrabalhadoresData trabalhador )
	{
		List<DefaultMutableTreeNode> result = new ArrayList<DefaultMutableTreeNode>();
		List<TrabalhadoresProcessoData> processos = trabalhador.fromTrabalhadoresProcesso_trabalhador_id();
		for( TrabalhadoresProcessoData trabalhadoresProcesso : processos )
		{
			result.add( loadProcesso( trabalhadoresProcesso ) );
		}
		return result;
	}

	private ProcessoMutableTreeNode loadProcesso( TrabalhadoresProcessoData processo )
	{
		ProcessoMutableTreeNode node = new ProcessoMutableTreeNode( processo );
		node.removeAllChildren();
		for( TrabalhadoresConsultasData current : processo.fromTrabalhadoresConsultas_processo_id() )
		{
			addNodeTo( loadConsulta( current ), node );
		}
		for( TrabalhadoresEcdsData current : processo.fromTrabalhadoresEcds_processo_id() )
		{
			addNodeTo( loadExame( current ), node );
		}

		List<TrabalhadoresFichasAptidaoData> fichas = processo.fromTrabalhadoresFichasAptidao_processo_id();
		if( fichas != null )
		{
			TrabalhadoresFichasAptidaoData ficha = null;
			for( TrabalhadoresFichasAptidaoData currentFicha : fichas )
			{
				if( ficha == null || ficha.getId() < currentFicha.getId() )
				{
					ficha = currentFicha;
				}
			}
			if( ficha != null )
			{
				addNodeTo( loadFicha( ficha ), node );
			}
		}
		return node;
	}

	private FichaAptidaoMutableTreeNode loadFicha( TrabalhadoresFichasAptidaoData ficha )
	{
		FichaAptidaoMutableTreeNode result = new FichaAptidaoMutableTreeNode( ficha );
		return result;
	}

	private ECDsMutableTreeNode loadExame( TrabalhadoresEcdsData exame )
	{
		ECDsMutableTreeNode node = new ECDsMutableTreeNode( exame );
		node.setData( exame.getData() );
		node.removeAllChildren();
		List<TrabalhadoresEcdsDatasData> marcacoes = exame.fromTrabalhadoresEcdsDatas_trabalhadores_ecds_id();
		for( TrabalhadoresEcdsDatasData marcacao : marcacoes )
		{
			addNodeTo( loadExameMarcacao( marcacao ), node );
		}
		return node;
	}

	private DataMutableTreeNode loadExameMarcacao( TrabalhadoresEcdsDatasData marcacao )
	{
		DataMutableTreeNode node = new DataMutableTreeNode( marcacao );
		for( TrabalhadoresEcdsDatasEmailsData email : marcacao.fromTrabalhadoresEcdsDatasEmails_trabalhadores_ecds_datas_id() )
		{
			addNodeTo( new MailMutableTreeNode( email ), node );
		}
		for( TrabalhadoresEcdsDatasObservacoesData observacoes : marcacao.fromTrabalhadoresEcdsDatasObservacoes_trabalhadores_ecds_datas_id() )
		{
			addNodeTo( new ObservacoesMutableTreeNode( observacoes ), node );
		}
		return node;
	}

	private ConsultaMutableTreeNode loadConsulta( TrabalhadoresConsultasData consulta )
	{
		ConsultaMutableTreeNode node = new ConsultaMutableTreeNode( consulta );
		node.setData( consulta.getData() );
		node.removeAllChildren();
		List<TrabalhadoresConsultasDatasData> marcacoes = consulta.fromTrabalhadoresConsultasDatas_trabalhadores_consultas_id();
		for( TrabalhadoresConsultasDatasData marcacao : marcacoes )
		{
			addNodeTo( loadMarcacao( marcacao ), node );
		}
		return node;
	}

	private DataMutableTreeNode loadMarcacao( TrabalhadoresConsultasDatasData marcacao )
	{
		DataMutableTreeNode node = new DataMutableTreeNode( marcacao );
		for( TrabalhadoresConsultasDatasEmailsData email : marcacao.fromTrabalhadoresConsultasDatasEmails_trabalhadores_consultas_datas_id() )
		{
			addNodeTo( new MailMutableTreeNode( email ), node );
		}
		for( TrabalhadoresConsultasDatasObservacoesData observacoes : marcacao.fromTrabalhadoresConsultasDatasObservacoes_trabalhadores_consultas_datas_id() )
		{
			addNodeTo( new ObservacoesMutableTreeNode( observacoes ), node );
		}
		return node;
	}

	private void addNodeTo( DefaultMutableTreeNode node, DefaultMutableTreeNode to )
	{
		if( node.getUserObject() != null && node.getUserObject() instanceof EvoDataObject )
		{
			nodeByObject.put( (EvoDataObject) node.getUserObject(), node );
		}
		to.add( node );
	}

	private void addAndRefresh( DefaultMutableTreeNode node, DefaultMutableTreeNode parentNode )
	{
		addNodeTo( node, parentNode );
		refresh( node, parentNode );
	}

	private void removeNode( DefaultMutableTreeNode node )
	{
		if( node != null )
		{
			DefaultMutableTreeNode parent = (DefaultMutableTreeNode) node.getParent();
			if( parent == null )
			{
				parent = rootNode;
			}
			node.removeFromParent();
			nodeByObject.remove( node.getUserObject() );
			refresh( parent, rootNode );
		}
	}

	private void refresh( DefaultMutableTreeNode newSelection, DefaultMutableTreeNode parentNode )
	{
		((DefaultTreeModel) mainTree.getModel()).nodeStructureChanged( parentNode );
		mainTree.setSelectionPath( new TreePath( newSelection.getPath() ) );
	}

	private DefaultMutableTreeNode getSelectedNode()
	{
		DefaultMutableTreeNode result = null;
		Object[] nodes = mainTree.getSelectionPath() == null ? null : mainTree.getSelectionPath().getPath();
		if( nodes != null && nodes.length > 0 && nodes[nodes.length - 1] instanceof DefaultMutableTreeNode )
		{
			result = (DefaultMutableTreeNode) nodes[nodes.length - 1];
		}
		return result;
	}

	public void clear()
	{
		rootNode.setUserObject( "" );
		mainTree.clearSelection();
		mainTree.setRootVisible( true );
		rootNode.removeAllChildren();
		((DefaultTreeModel) mainTree.getModel()).nodeStructureChanged( rootNode );
	}
}