package com.jsql.view.swing.tab.dnd;
   
   import com.jsql.util.LogLevelUtil;
   import com.jsql.view.swing.action.ActionCloseTabResult;
   import org.apache.logging.log4j.LogManager;
   import org.apache.logging.log4j.Logger;
   
   import javax.swing.*;
   import java.awt.*;
  import java.awt.dnd.DragSource;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.util.Objects;
  import java.util.Optional;
  
  public class DnDTabbedPane extends JTabbedPane {
  
      /**
       * Log4j logger sent to view.
       */
      private static final Logger LOGGER = LogManager.getRootLogger();
  
      private static final int SCROLL_SIZE = 20;  // Test
      private static final int BUTTON_SIZE = 30;  // 30 is magic number of scroll button size
      private static final int LINE_WIDTH = 3;
      private static final Rectangle RECT_BACKWARD = new Rectangle();
      private static final Rectangle RECT_FORWARD = new Rectangle();
      protected static final Rectangle RECT_LINE = new Rectangle();
      protected int dragTabIndex = -1;
      private transient DnDDropLocation dropLocation;
  
      public static final class DnDDropLocation extends TransferHandler.DropLocation {
          
          private final int index;
          private boolean dropable = true;
          
          private DnDDropLocation(Point p, int index) {
              super(p);
              this.index = index;
          }
          
          public int getIndex() {
              return this.index;
          }
          
          public void setDroppable(boolean flag) {
              this.dropable = flag;
          }
          
          public boolean isDroppable() {
              return this.dropable;
          }
      }
      
      private void clickArrowButton(String actionKey) {
          JButton scrollForwardButton = null;
          JButton scrollBackwardButton = null;
          
          for (Component c: this.getComponents()) {
              if (c instanceof JButton) {
                  if (scrollForwardButton == null) {
                      scrollForwardButton = (JButton) c;
                  } else if (scrollBackwardButton == null) {
                      scrollBackwardButton = (JButton) c;
                  }
              }
          }
          
          JButton button = "scrollTabsForwardAction".equals(actionKey) ? scrollForwardButton : scrollBackwardButton;
          Optional.ofNullable(button)
              .filter(JButton::isEnabled)
              .ifPresent(JButton::doClick);
      }
      
      public void autoScrollTest(Point pt) {
          Rectangle r = this.getTabAreaBounds();
          
          if (DnDTabbedPane.isTopBottomTabPlacement(this.getTabPlacement())) {
              DnDTabbedPane.RECT_BACKWARD.setBounds(r.x, r.y, DnDTabbedPane.SCROLL_SIZE, r.height);
              DnDTabbedPane.RECT_FORWARD.setBounds(r.x + r.width - DnDTabbedPane.SCROLL_SIZE - DnDTabbedPane.BUTTON_SIZE, r.y, DnDTabbedPane.SCROLL_SIZE + DnDTabbedPane.BUTTON_SIZE, r.height);
          } else {
              DnDTabbedPane.RECT_BACKWARD.setBounds(r.x, r.y, r.width, DnDTabbedPane.SCROLL_SIZE);
              DnDTabbedPane.RECT_FORWARD.setBounds(r.x, r.y + r.height - DnDTabbedPane.SCROLL_SIZE - DnDTabbedPane.BUTTON_SIZE, r.width, DnDTabbedPane.SCROLL_SIZE + DnDTabbedPane.BUTTON_SIZE);
          }
          
          if (DnDTabbedPane.RECT_BACKWARD.contains(pt)) {
              this.clickArrowButton("scrollTabsBackwardAction");
          } else if (DnDTabbedPane.RECT_FORWARD.contains(pt)) {
              this.clickArrowButton("scrollTabsForwardAction");
          }
      }
      
      protected DnDTabbedPane() {
          super();
          
          var h = new Handler();
          this.addMouseListener(h);
         this.addMouseMotionListener(h);
         this.addPropertyChangeListener(h);
     }
     
     public DnDDropLocation dropLocationForPointDnD(Point p) {
         for (var i = 0; i < this.getTabCount(); i++) {
             if (this.getBoundsAt(i).contains(p)) {
                 return new DnDDropLocation(p, i);
             }
         }
         
         if (this.getTabAreaBounds().contains(p)) {
             return new DnDDropLocation(p, this.getTabCount());
         }
         
         return new DnDDropLocation(p, -1);
     }
     
     public void setDropLocation(TransferHandler.DropLocation location, boolean forDrop) {
         DnDDropLocation old = this.dropLocation;
         
         if (Objects.isNull(location) || !forDrop) {
             this.dropLocation = new DnDDropLocation(new Point(), -1);
         } else if (location instanceof DnDDropLocation) {
             this.dropLocation = (DnDDropLocation) location;
         }
         
         this.firePropertyChange("dropLocation", old, this.dropLocation);
     }
     
     public void exportTab(int dragIndex, JTabbedPane target, int targetIndex) {
         var cmp = this.getComponentAt(dragIndex);
         var tab = this.getTabComponentAt(dragIndex);
         String title = this.getTitleAt(dragIndex);
         var icon = this.getIconAt(dragIndex);
         String tip = this.getToolTipTextAt(dragIndex);
         boolean isEnabled = this.isEnabledAt(dragIndex);
         
         this.remove(dragIndex);
         target.insertTab(title, icon, cmp, tip, targetIndex);
         target.setEnabledAt(targetIndex, isEnabled);
 
         target.setTabComponentAt(targetIndex, tab);
         target.setSelectedIndex(targetIndex);
         
         if (tab instanceof JComponent) {
             ((JComponent) tab).scrollRectToVisible(tab.getBounds());
         }
     }
     
     public void convertTab(int prev, int next) {
         var cmp = this.getComponentAt(prev);
         var tab = this.getTabComponentAt(prev);
         String title = this.getTitleAt(prev);
         var icon = this.getIconAt(prev);
         String tip = this.getToolTipTextAt(prev);
         boolean isEnabled = this.isEnabledAt(prev);
         int tgtindex = prev > next ? next : next - 1;
         
         this.remove(prev);
         this.insertTab(title, icon, cmp, tip, tgtindex);
         this.setEnabledAt(tgtindex, isEnabled);
         
         // When you drag'n'drop a disabled tab, it finishes enabled and selected.
         // pointed out by dlorde
         if (isEnabled) {
             this.setSelectedIndex(tgtindex);
         }
         
         // I have a component in all tabs (jlabel with an X to close the tab) and when I move a tab the component disappear.
         // pointed out by Daniel Dario Morales Salas
         this.setTabComponentAt(tgtindex, tab);
     }
     
     public Optional<Rectangle> getDropLineRect() {
         int index = Optional.ofNullable(this.getDropLocation())
             .filter(DnDDropLocation::isDroppable)
             .map(DnDDropLocation::getIndex)
             .orElse(-1);
         
         if (index < 0) {
             DnDTabbedPane.RECT_LINE.setBounds(0, 0, 0, 0);
             return Optional.empty();
         }
         
         int a = Math.min(index, 1);
         Rectangle r = this.getBoundsAt(a * (index - 1));
         
         if (DnDTabbedPane.isTopBottomTabPlacement(this.getTabPlacement())) {
             DnDTabbedPane.RECT_LINE.setBounds(r.x - DnDTabbedPane.LINE_WIDTH / 2 + r.width * a, r.y, DnDTabbedPane.LINE_WIDTH, r.height);
         } else {
             DnDTabbedPane.RECT_LINE.setBounds(r.x, r.y - DnDTabbedPane.LINE_WIDTH / 2 + r.height * a, r.width, DnDTabbedPane.LINE_WIDTH);
         }
         
         return Optional.of(DnDTabbedPane.RECT_LINE);
     }
     
     public Rectangle getTabAreaBounds() {
         Rectangle tabbedRect = this.getBounds();
         int xx = tabbedRect.x;
         int yy = tabbedRect.y;
         
         Rectangle compRect = Optional.ofNullable(this.getSelectedComponent())
             .map(Component::getBounds)
             .orElseGet(Rectangle::new);
 
         int tabPlacement = this.getTabPlacement();
         
         if (DnDTabbedPane.isTopBottomTabPlacement(tabPlacement)) {
             tabbedRect.height = tabbedRect.height - compRect.height;
             if (tabPlacement == SwingConstants.BOTTOM) {
                 tabbedRect.y += compRect.y + compRect.height;
             }
         } else {
             tabbedRect.width = tabbedRect.width - compRect.width;
             if (tabPlacement == SwingConstants.RIGHT) {
                 tabbedRect.x += compRect.x + compRect.width;
             }
         }
         
         tabbedRect.translate(-xx, -yy);
         return tabbedRect;
     }
 
     public static boolean isTopBottomTabPlacement(int tabPlacement) {
         return tabPlacement == SwingConstants.TOP || tabPlacement == SwingConstants.BOTTOM;
     }
 
     private class Handler extends MouseAdapter implements PropertyChangeListener { // , BeforeDrag
         
         private Point startPt;
         private final int gestureMotionThreshold = DragSource.getDragThreshold();
 
         private void repaintDropLocation() {
             Component c = DnDTabbedPane.this.getRootPane().getGlassPane();
             if (c instanceof GhostGlassPane) {
                 GhostGlassPane glassPane = (GhostGlassPane) c;
                 glassPane.setTargetTabbedPane(DnDTabbedPane.this);
                 glassPane.repaint();
             }
         }
         
         // PropertyChangeListener
         @Override
         public void propertyChange(PropertyChangeEvent e) {
             String propertyName = e.getPropertyName();
             if ("dropLocation".equals(propertyName)) {
                 this.repaintDropLocation();
             }
         }
         
         // MouseListener
         @Override
         public void mousePressed(MouseEvent e) {
             DnDTabbedPane src = (DnDTabbedPane) e.getComponent();
             boolean isOnlyOneTab = src.getTabCount() <= 1;
             if (isOnlyOneTab) {
                 this.startPt = null;
                 return;
             }
             
             var tabPt = e.getPoint();
             int idx;
             // Fix #95782: IllegalArgumentException on indexAtLocation()
             try {
                 idx = src.indexAtLocation(tabPt.x, tabPt.y);
             } catch (IllegalArgumentException err) {
                 LOGGER.log(LogLevelUtil.CONSOLE_JAVA, err);
                 return;
             }
             
             // disabled tab, null component problem.
             // pointed out by daryl. NullPointerException: i.e. addTab("Tab", null)
             boolean flag = idx < 0 || !src.isEnabledAt(idx) || Objects.isNull(src.getComponentAt(idx));
             
             this.startPt = flag ? null : tabPt;
         }
         
         @Override
         public void mouseDragged(MouseEvent e) {
             var tabPt = e.getPoint();
             if (Objects.nonNull(this.startPt) && this.startPt.distance(tabPt) > this.gestureMotionThreshold) {
                 DnDTabbedPane src = (DnDTabbedPane) e.getComponent();
                 var th = src.getTransferHandler();
                 DnDTabbedPane.this.dragTabIndex = src.indexAtLocation(tabPt.x, tabPt.y);
                 
                 // Unhandled NoClassDefFoundError #56620: Could not initialize class java.awt.dnd.DragSource
                 th.exportAsDrag(src, e, TransferHandler.MOVE);
 
                 DnDTabbedPane.RECT_LINE.setBounds(0, 0, 0, 0);
                 src.getRootPane().getGlassPane().setVisible(true);
                 src.setDropLocation(new DnDDropLocation(tabPt, -1), true);
                 
                 this.startPt = null;
             }
         }
 
         @Override
         public void mouseClicked(MouseEvent e) {
             var tabPt = e.getPoint();
             JTabbedPane src = (JTabbedPane) e.getSource();
             
             int i = src.indexAtLocation(tabPt.x, tabPt.y);
             if (-1 < i && e.getButton() == MouseEvent.BUTTON2) {
                 ActionCloseTabResult.perform(i);
             }
         }
     }
     
     public final DnDDropLocation getDropLocation() {
         return this.dropLocation;
     }
 }