/* copyright

This file is part of JKomasto2.
Written in 2022 by Usawashi <usawashi16@yahoo.co.jp>

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 <https://www.gnu.org/licenses/>.

copyright */

import javax.swing.JComponent;
import javax.swing.ImageIcon;
import java.awt.Graphics;
import java.awt.FontMetrics;
import java.awt.Image;
import java.awt.Color;
import java.awt.Dimension;
import java.util.List;
import java.util.LinkedList;
import java.util.ListIterator;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseEvent;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;

class
RichTextPane extends JComponent
implements MouseListener, MouseMotionListener, KeyListener {

    private List<Segment>
    text;

    private int
    selectionStart, selectionEnd;

//    ---%-@-%---

    public void
    setText(List<Segment> text)
    {
        this.text = text;
        selectionStart = selectionEnd = -1;
    }

    public List<Segment>
    getSelection()
    {
        List<Segment> returnee = new LinkedList<>();
        if (selectionEnd == -1) return returnee;

        if (selectionEnd < selectionStart) {
            int t = selectionEnd;
            selectionEnd = selectionStart;
            selectionStart = t;
        }
        returnee.addAll(text.subList(selectionStart + 1, selectionEnd));
        return returnee;
    }

    public void
    copySelection()
    {
        assert selectionEnd != -1;
        StringBuilder b = new StringBuilder();
        for (Segment segment: getSelection())
        {
            if (segment.link != null) b.append(segment.link);
            else if (segment.text != null) b.append(segment.text);
        }
        ClipboardApi.serve(b.toString());
    }

//     -    -%-     -

    protected void
    paintComponent(Graphics g)
    {
        g.setFont(getFont());
        FontMetrics fm = g.getFontMetrics(getFont());

        if (isOpaque())
            g.clearRect(0, 0, getWidth(), getHeight());

        ((java.awt.Graphics2D)g).setRenderingHint(
            java.awt.RenderingHints.KEY_TEXT_ANTIALIASING,
            java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON
        );

        int o = 0;
        for (Segment segment: text)
        {
            if (segment.image != null) {
                int ow = segment.image.getIconWidth();
                int oh = segment.image.getIconHeight();
                int h = fm.getAscent() + fm.getDescent();
                int w = h * ow / oh;
                int x = segment.x;
                int y = segment.y + fm.getDescent();
                // Interpret segment.y as specifying text baseline
                Image img = segment.image.getImage();
                g.drawImage(img, x, y - h, w, h, this);
                continue;
            }

            if (o > selectionStart && o < selectionEnd)
            {
                int dx = fm.stringWidth(segment.text);
                int dy1 = fm.getAscent();
                int dy2 = dy1 + fm.getDescent();
                g.setColor(new Color(0, 0, 0, 15));
                g.fillRect(segment.x, segment.y - dy1, dx, dy2);
                g.setColor(getForeground());
            }

            if (segment.link != null) g.setColor(Color.BLUE);
            g.drawString(segment.text, segment.x, segment.y);
            g.setColor(getForeground());

            ++o;
        }
    }

    public void
    mousePressed(MouseEvent eM)
    {
        requestFocusInWindow();
        selectionStart = identify(eM.getX(), eM.getY()) - 2;
        selectionEnd = -1;
        repaint();
    }

    public void
    mouseDragged(MouseEvent eM)
    {
        selectionEnd = identify(eM.getX(), eM.getY());
        repaint();
    }

    private int
    identify(int x, int y)
    {
        FontMetrics fm = getFontMetrics(getFont());
        int iy = fm.getAscent();
        int lh = fm.getAscent() + fm.getDescent();
        y -= fm.getDescent();
        if (y <= iy) y = iy;
        else y += lh - ((y - iy) % lh);
        /*
        * Snaps y to the next baseline. Kind of obtuse,
        * but it wasn't randomly derived, anyways
        * you can test it for 13, 30, 47, etc.
        */

        int o = 0;
        for (Segment segment: text)
        {
            if (segment.y == y && segment.x > x) break;
            if (segment.y > y) break;
            ++o;
        }
        return o;
    }

    public void
    keyPressed(KeyEvent eK)
    {
        if (selectionEnd == -1) return;
        if (eK.getKeyCode() != KeyEvent.VK_C) return;
        if (!eK.isControlDown()) return;
        copySelection();
    }


    public void
    keyReleased(KeyEvent eK) { }

    public void
    keyTyped(KeyEvent eK) { }

    public void
    mouseClicked(MouseEvent eM) { }

    public void
    mouseReleased(MouseEvent eM) { }

    public void
    mouseEntered(MouseEvent eM) { }

    public void
    mouseExited(MouseEvent eM) { }

    public void
    mouseMoved(MouseEvent eM) { }

//     -    -%-     -

    public static List<Segment>
    layout(List<Segment> text, FontMetrics fm, int width)
    {
        List<Segment> copy = new LinkedList<>();
        for (Segment segment: text) copy.add(segment.clone());
        text = copy;
        ListIterator<Segment> cursor = text.listIterator();
        int x = 0, y = fm.getAscent();
        int dy = fm.getAscent() + fm.getDescent();
        while (cursor.hasNext())
        {
            Segment curr = cursor.next();

            int dx;
            if (curr.image != null) {
                int ow = curr.image.getIconWidth();
                int oh = curr.image.getIconHeight();
                int nh = fm.getAscent() + fm.getDescent();
                dx = nh * ow / oh;
            }
            else if (curr.text != null) {
                dx = fm.stringWidth(curr.text);
            }
            else if (curr.link != null) {
                curr.text = curr.link;
                dx = fm.stringWidth(curr.link);
            }
            else {
                assert false;
                dx = 0;
            }

            boolean fits = x + dx < width;

            if (fits || curr.spacer)
            {
                curr.x = x;
                curr.y = y;
                x += dx;
                if (curr.spacer && curr.text.equals("\n")) {
                    y += dy;
                    x = 0;
                }
                continue;
            }

            boolean tooLong = dx > width;
            boolean canFitChar = width >= fm.getMaxAdvance();
            boolean splittable = curr.image == null;
            /*
            * A bit of redundancy in my conditions, but the point is
            * to exactly express the triggers in my mental model.
            * The conditions should read more like English.
            */

            if (!tooLong || (tooLong && !splittable))
            {
                curr.x = 0;
                curr.y = y += dy;
                x = dx;
                continue;
            }

            assert tooLong && splittable;

            String s = curr.text;
            int splitOffset;
            for (splitOffset = 0; splitOffset < s.length(); ++splitOffset)
            {
                String substring = s.substring(0, splitOffset + 1);
                if (fm.stringWidth(substring) > width) break;
            }
            if (splitOffset == 0) splitOffset = 1;
            /*
            * I force a split even if our width supports no characters.
            * Because if I don't split, the only alternatives to infinitely
            * looping downwards is to emplace this segment or ignore it.
            */
            Segment fitted = new Segment();
            fitted.text = s.substring(0, splitOffset);
            fitted.link = curr.link;
            fitted.x = x;
            fitted.y = y;
            cursor.add(fitted);
            curr.text = s.substring(splitOffset);
            y += dy;
            x = 0;
            cursor.add(curr); cursor.previous();
            /*
            * I had to use a stack and return a new list because,
            * splitting can turn a long segment into several spread
            * over different lines. Here curr becomes the "after-split"
            * and I push it back to the stack.
            *
            * If #layout wasn't a separate method, but rather only for
            * graphical painting. Then I don't need a stack nor return
            * a new list. I iterate over the given one, filling the
            * nodes' geometric information, if a split occurs I save the
            * "after-split" in a variable, which in the next iteration
            * I use as curr instead of list.next(). The caller doesn't
            * need to know the geometry of these intermediate segments.
            */
            continue;
        }

        return text;
    }

//    ---%-@-%---

    public static class
    Segment {

        public ImageIcon
        image;

        public String
        link;

        public String
        text;

        public boolean
        spacer;

        public int
        x, y;

//        -=%=-

        public String
        toString()
        {
            StringBuilder b = new StringBuilder();
            b.append(getClass().getName() + "[");
            b.append("image=" + image);
            b.append(",link=" + link);
            b.append(",text=" + text);
            b.append(",x=" + x);
            b.append(",y=" + y);
            b.append("]");
            return b.toString();
        }

        public Segment
        clone()
        {
            Segment segment = new Segment();
            segment.image = this.image;
            segment.link = this.link;
            segment.text = this.text;
            segment.spacer = this.spacer;
            segment.x = this.x;
            segment.y = this.y;
            return segment;
        }

    }

    public static class
    Builder {

        private List<Segment>
        returnee;

//        -=%=-

        public
        Builder() { returnee = new LinkedList<>(); }

        public Builder
        image(ImageIcon image, String text)
        {
            Segment segment = new Segment();
            segment.image = image;
            segment.text = text;
            returnee.add(segment);
            return this;
        }

        public Builder
        link(String link, String text)
        {
            Segment segment = new Segment();
            segment.link = link;
            segment.text = text;
            returnee.add(segment);
            return this;
        }

        public Builder
        text(String text)
        {
            Segment segment = new Segment();
            segment.text = text;
            returnee.add(segment);
            return this;
        }

        public Builder
        spacer(String text)
        {
            Segment segment = new Segment();
            segment.text = text;
            segment.spacer = true;
            returnee.add(segment);
            return this;
        }

        public List<Segment>
        finish() { return returnee; }

    }

//    ---%-@-%---

    RichTextPane()
    {
        text = new LinkedList<>();

        addMouseListener(this);
        addMouseMotionListener(this);
        addKeyListener(this);
    }

}