package jmri.jmrit.roster.swing.functiontable;

import java.awt.datatransfer.*;
import java.io.IOException;

import javax.swing.*;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import jmri.jmrit.roster.RosterEntry;
import jmri.jmrit.roster.RosterFunctionEntry;
import jmri.util.datatransfer.RosterEntrySelection;
import jmri.util.iharder.dnd.URIDrop;
import jmri.util.swing.EditableResizableImagePanel;

/**
 * A TransferHandler that handl drag'n drop over the FunctionTable. 
 * It can handle rows drag'n drop but also drag'n drop into the EditableResizableImagePanel in some of the table cells.
 * 
 * It is used in the FunctionLabelPane.
 * 
 * <hr>
 * This file is part of JMRI.
 * <p>
 * JMRI is free software; you can redistribute it and/or modify it under the
 * terms of version 2 of the GNU General Public License as published by the Free
 * Software Foundation. See the "COPYING" file for a copy of this license.
 * <p>
 * JMRI 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.
 *
 * @author Lionel Jeanson 2009-2026
 */

public class FunctionTableRowTransferHandler extends TransferHandler {
    private final JTable table;
    private final DataFlavor rowFlavor = new DataFlavor(MyTransferData.class, "function table row+rosterentry+rosterfunctionentry");

    public FunctionTableRowTransferHandler(JTable table) {
        this.table = table;
    }

    @Override
    protected Transferable createTransferable(JComponent c) {
        return new DataHandler(table.getSelectedRow(), ((FunctionTableModel)table.getModel()).getRosterEntry(), ((FunctionTableModel)table.getModel()).getRosterFunctionEntryAtRow(table.getSelectedRow()), rowFlavor);
    }

    @Override
    public boolean canImport(TransferSupport support) {
        EditableResizableImagePanel impan = FunctionTableMouseListener.getEditableResizableImagePanelAt(table, support.getDropLocation().getDropPoint().x, support.getDropLocation().getDropPoint().y);
        if (impan != null) {
            for (DataFlavor df :  support.getDataFlavors()) {
                if (df.isRepresentationClassReader()) {
                    return true;
                }
            }
            return ( support.isDataFlavorSupported(DataFlavor.imageFlavor) ||
                     support.isDataFlavorSupported(DataFlavor.javaFileListFlavor) ||
                     support.isDataFlavorSupported(DataFlavor.stringFlavor));
        }
        return support.isDrop() && ( support.isDataFlavorSupported(rowFlavor) || support.isDataFlavorSupported(RosterEntrySelection.rosterEntryFlavor));
    }

    @Override
    public int getSourceActions(JComponent c) {
        return MOVE;
    }

    @Override
    @SuppressFBWarnings(value = "BC_UNCONFIRMED_CAST_OF_RETURN_VALUE", justification = "There is an instanceof test just before the cast.")
    public boolean importData(TransferSupport support) {
        if ( !canImport(support) || !(support.getDropLocation() instanceof JTable.DropLocation)) {
            log.debug("TransferSupport() can't do import");
            return false;
        }
        JTable.DropLocation drop = (JTable.DropLocation) support.getDropLocation();
        // is if a drop on an imageicon?
        EditableResizableImagePanel impan = FunctionTableMouseListener.getEditableResizableImagePanelAt(table, drop.getDropPoint().x, drop.getDropPoint().y);
        if (impan != null) {
            if ( URIDrop.importExternalTransferable(support.getTransferable(), impan)) {
                return true;
            }
            log.debug("Drop on image, but not importable as image, trying other possibilities");
        }
        // a RosterEntry?
        if (support.isDataFlavorSupported(RosterEntrySelection.rosterEntryFlavor)) {
            log.debug("Dropping a roster entry -> copy all functions");
            try {
                RosterEntry re = RosterEntrySelection.getRosterEntries(support.getTransferable()).get(0);
                ((FunctionTableModel)table.getModel()).reset(re.getFunctionEntries(), re.getShuntingFunction(), re.getAttribute(FunctionTableModel.FB_ORDER_ATTR));
                return true;
            } catch (UnsupportedFlavorException | IOException | ClassCastException e) {
                log.error("Could not drag'n drop roster entry.", e);
            }
        }
        // else must be a row
        try {
            MyTransferData data = (MyTransferData) support.getTransferable().getTransferData(rowFlavor);
            int to = drop.getRow();
            if ( data.getRosterEntry().getDccLocoAddress().equals( ((FunctionTableModel)table.getModel()).getRosterEntry().getDccLocoAddress() )) { 
                log.debug("Dropping a row from the same roster entry -> reorder");
                int from = data.getRow();
                if (to < 0 || from == to || from + 1 == to) {
                    log.debug("TransferSupport() can't do import : same indexes");
                    return false;
                }
                ((FunctionTableModel) table.getModel()).moveRow(from, to > from ? to - 1 : to);
                table.getSelectionModel().setSelectionInterval( to > from ? to - 1 : to, to > from ? to - 1 : to );
            } else {
                log.debug("Dropping a row from another roster entry -> copy function properties");
                ((FunctionTableModel)table.getModel()).setRosterFunctionEntryAtRow(data.getRosterFunctionEntry(), to);
            }
            return true;
        } catch (UnsupportedFlavorException | IOException e) {
            log.debug("importData() Exception : ", e);
        }
        log.debug("Couldn't import.");
        return false;
    }

    private static class DataHandler implements Transferable {
        private final MyTransferData transferData;
        private final DataFlavor flavor;

        DataHandler(Integer row, RosterEntry re, RosterFunctionEntry fe, DataFlavor flavor) {
            this.transferData = new MyTransferData(row, re, fe);
            this.flavor = flavor;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return new DataFlavor[] { flavor };
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor f) {
            return flavor.equals(f);
        }

        @Override
        public Object getTransferData(DataFlavor f)
                throws UnsupportedFlavorException {
            if (!isDataFlavorSupported(f)) {
                throw new UnsupportedFlavorException(f);
            }
            return transferData;
        }
    }

    private static class MyTransferData {
        private final int row;
        private final RosterEntry rosterEntry;
        private final RosterFunctionEntry functionEntry;
        
        MyTransferData(int r, RosterEntry re, RosterFunctionEntry fe) {
            row = r;
            rosterEntry = re;
            functionEntry = fe;
        }

        int getRow() {
            return row;
        }

        RosterEntry getRosterEntry() {
            return rosterEntry;
        }

        RosterFunctionEntry getRosterFunctionEntry() {
            return functionEntry;
        }        
    }

    private static final Logger log = LoggerFactory.getLogger(FunctionTableRowTransferHandler.class);
}