/*******************************************************************************
 *     SDR Trunk 
 *     Copyright (C) 2014-2016 Dennis Sheirer
 * 
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 * 
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 * 
 *     You should have received a copy of the GNU General Public License
 *     along with this program.  If not, see <http://www.gnu.org/licenses/>
 ******************************************************************************/
package alias;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;

import javax.swing.table.AbstractTableModel;

import alias.id.broadcast.BroadcastChannel;
import sample.Broadcaster;
import sample.Listener;
import alias.AliasEvent.Event;

/**
 * Alias Model
 */
public class AliasModel extends AbstractTableModel
{
	private static final long serialVersionUID = 1L;

	public static final int COLUMN_LIST = 0;
	public static final int COLUMN_GROUP = 1;
	public static final int COLUMN_NAME = 2;
	public static final int COLUMN_ICON = 3;
	public static final int COLUMN_COLOR = 4;

	private List<Alias> mAliases = new CopyOnWriteArrayList<>();
	private Broadcaster<AliasEvent> mAliasEventBroadcaster = new Broadcaster<>();
	private Map<String,AliasList> mAliasListMap = new HashMap<>();

	public AliasModel()
	{
	}

	/**
	 * Unmodifiable list of all aliases currently in the model
	 */
	public List<Alias> getAliases()
	{
		return Collections.unmodifiableList( mAliases );
	}
	
	public Alias getAliasAtIndex( int row )
	{
		if( mAliases.size() >= row )
		{
			return mAliases.get( row );
		}
		
		return null;
	}
	
	public AliasList getAliasList( String name )
	{
		if( mAliasListMap.containsKey( name ) )
		{
			return mAliasListMap.get( name );
		}
		
		AliasList aliasList = new AliasList( name );
		
		for( Alias alias: mAliases )
		{
			if( alias.getList().equalsIgnoreCase( name ) )
			{
				aliasList.addAlias( alias );
			}
		}

		mAliasListMap.put( name, aliasList );

		//Register the new alias list to receive updates from this model
		addListener( aliasList );
		
		return aliasList;
	}
	
	/**
	 * Returns a list of unique alias list names from across the alias set
	 */
	public List<String> getListNames()
	{
		List<String> listNames = new ArrayList<>();
		
		for( Alias alias: mAliases )
		{
			if( alias.hasList() && !listNames.contains( alias.getList() ) )
			{
				listNames.add( alias.getList() );
			}
		}
		
		Collections.sort( listNames );
		
		return listNames;
	}
	
	/**
	 * Returns a list of alias group names for all aliases
	 */
	public List<String> getGroupNames()
	{
		List<String> groupNames = new ArrayList<>();

		for( Alias alias: mAliases )
		{
			if( alias.hasGroup() &&	!groupNames.contains( alias.getGroup() ) )
			{
				groupNames.add( alias.getGroup() );
			}
		}

		Collections.sort( groupNames );
		
		return groupNames;
	}

	/**
	 * Returns a list of alias group names for all aliases that have a matching
	 * list name value
	 */
	public List<String> getGroupNames( String listName )
	{
		List<String> groupNames = new ArrayList<>();

		if( listName != null )
		{
			for( Alias alias: mAliases )
			{
				if( alias.hasList() && 
					alias.hasGroup() &&
					listName.equals( alias.getList() ) &&
					!groupNames.contains( alias.getGroup() ) )
				{
					groupNames.add( alias.getGroup() );
				}
			}
		}

		Collections.sort( groupNames );
		
		return groupNames;
	}

	/**
	 * Bulk loading of aliases
	 */
	public void addAliases( List<Alias> aliases )
	{
		for( Alias alias: aliases )
		{
			addAlias( alias );
		}
	}

	/**
	 * Adds the alias to the model
	 */
	public int addAlias( Alias alias )
	{
		if( alias != null )
		{
			mAliases.add( alias );

			int index = mAliases.size() - 1;

			fireTableRowsInserted( index, index );
			
			broadcast( new AliasEvent( alias, Event.ADD ) );

			return index;
		}
		
		return -1;
	}
	
	/**
	 * Removes the channel from the model and broadcasts a channel remove event
	 */
	public void removeAlias( Alias alias )
	{
		if( alias != null )
		{
			int index = mAliases.indexOf( alias );
			
			mAliases.remove( alias );
			
			fireTableRowsDeleted( index, index );
			
			broadcast( new AliasEvent( alias, Event.DELETE ) );
		}
	}

    /**
     * Renames any broadcast channels that have the previous name.
     * @param previousName to rename
     * @param newName to assign to the broadcast channel
     */
    public void renameBroadcastChannel(String previousName, String newName)
    {
        if(previousName == null || previousName.isEmpty() || newName == null || newName.isEmpty())
        {
            return;
        }

        for(Alias alias: mAliases)
        {
            if(alias.hasBroadcastChannel(previousName))
            {
                for(BroadcastChannel broadcastChannel: alias.getBroadcastChannels())
                {
                    if(broadcastChannel.getChannelName().contentEquals(previousName))
                    {
                        broadcastChannel.setChannelName(newName);
                    }
                }
            }
        }
    }

	@Override
	public int getRowCount()
	{
		return mAliases.size();
	}

	@Override
	public int getColumnCount()
	{
		return 5;
	}

	@Override
	public String getColumnName( int columnIndex )
	{
		switch( columnIndex )
		{
			case COLUMN_LIST:
				return "List";
			case COLUMN_GROUP:
				return "Group";
			case COLUMN_NAME:
				return "Name";
			case COLUMN_ICON:
				return "Icon";
			case COLUMN_COLOR:
				return "Color";
		}
		
		return null;
	}

	@Override
	public Class<?> getColumnClass( int columnIndex )
	{
		if( columnIndex == COLUMN_COLOR )
		{
			return Integer.class;
		}
		
		return String.class;
	}

	@Override
	public boolean isCellEditable( int rowIndex, int columnIndex )
	{
		return false;
	}

	@Override
	public Object getValueAt( int rowIndex, int columnIndex )
	{
		Alias alias = mAliases.get( rowIndex );
		
		switch( columnIndex )
		{
			case COLUMN_LIST:
				return alias.getList();
			case COLUMN_GROUP:
				return alias.getGroup();
			case COLUMN_NAME:
				return alias.getName();
			case COLUMN_ICON:
				return alias.getIconName();
			case COLUMN_COLOR:
				return alias.getColor();
		}
		
		return null;
	}

	@Override
	public void setValueAt( Object aValue, int rowIndex, int columnIndex )
	{
		throw new IllegalArgumentException( "Not yet implemented" );
	}
	
	public void broadcast( AliasEvent event )
	{
        Alias alias = event.getAlias();

        //Validate the alias following a user action that changed the alias or any alias IDs
        if(alias != null)
        {
            alias.validate();
        }

		if( event.getEvent() == Event.CHANGE )
		{
			int index = mAliases.indexOf( event.getAlias() );
			
			fireTableRowsUpdated( index, index );
		}
		
		mAliasEventBroadcaster.broadcast( event );
	}
	
	public void addListener( Listener<AliasEvent> listener )
	{
		mAliasEventBroadcaster.addListener( listener );
	}
	
	public void removeListener( Listener<AliasEvent> listener )
	{
		mAliasEventBroadcaster.removeListener( listener );
	}
}