package com.vinni.semantarus.syntax.display;

import com.vinni.semantarus.syntax.structure.Phrase;
import com.vinni.semantarus.syntax.variants.VariantTree;
import com.vinni.semantarus.utility.image.DiskMemImage;
import org.apache.log4j.Logger;

import java.awt.*;
import java.awt.font.TextLayout;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.RenderedImage;
import java.awt.image.SampleModel;
import java.util.LinkedList;

/**
 * @author Arseni Buinitsky
 *
 * Date: Nov 21, 2009; Time: 12:56:08 AM
 *
 * Класс для отображения синтаксических структур на картинках
 */
public class SyntaxDisplayer {
    VariantTreeBuilder treeBuilder = new HorisontalVariantTreeBuilder();
    SyntaxDisplayerTheme theme = new DefaultSyntaxDisplayerTheme();
    LinkedList<CustomDrawer> customDrawers = new LinkedList<CustomDrawer>();

    public static final int VARIANT_TREE_NODES_LIMIT = 800;
    public static final int IMAGE_TILE_WIDTH = 512;
    public static final int IMAGE_TILE_HEIGHT = 512;
    public static final long TILED_IMAGE_CACHE_SIZE = 300L * 1024 * 1024;

    public static final boolean USE_DISK_BACKED_IMAGE = false;

    private static BufferedImage failImage = null;

    private static final Logger log = Logger.getLogger(SyntaxDisplayer.class);

    public void addCustomDrawer(CustomDrawer customDrawer) {
        customDrawers.add(customDrawer);
    }

    public void removeCustomDrawer(CustomDrawer customDrawer) {
        customDrawers.remove(customDrawer);
    }

    public RenderedImage display(Phrase p) {
        log.debug(String.format("отрисовка фразы, %d узлов, \"%s\"", p.size(), p.toWordsString()));
        return display(cook(p));
    }

    public RenderedImage display(Phrase p, String description) {
        log.debug(String.format("отрисовка фразы, %d узлов, \"%s\"", p.size(), p.toWordsString()));
        DisplayablePhrase displayablePhrase = cook(p);
        displayablePhrase.setDescription(description);
        return display(displayablePhrase);
    }

    public RenderedImage display(VariantTree tree) {
        log.debug(String.format("отрисовка VariantTree, %d узлов, \"%s\"", tree.getTotalNodes(), tree.getSentence()));
        return display(cook(tree));
    }

    public RenderedImage display(VariantTree tree, String description) {
        log.debug(String.format("отрисовка VariantTree, %d узлов, \"%s\"", tree.getTotalNodes(), tree.getSentence()));
        DisplayableVariantTree displayableVariantTree = cook(tree);
        displayableVariantTree.setDescription(description);
        return display(displayableVariantTree);
    }

    public DisplayableVariantTree cook(VariantTree tree) {
        log.trace(String.format("готовим VariantTree, %d узлов...", tree.getTotalNodes()));
        if (tree.getAllVariants().size() >= VARIANT_TREE_NODES_LIMIT) {
            throw new RuntimeException("" + VARIANT_TREE_NODES_LIMIT + " leaves is too much to display VariantTree");
        }
        DisplayableVariantTree cookedTree = treeBuilder.build(tree, theme);
        log.trace("VariantTree приготовлено");
        return cookedTree;
    }

    public DisplayablePhrase cook(Phrase phrase) {
        return new DisplayablePhrase(null, null, phrase, theme);
    }

    public RenderedImage display(DisplayableItem item) {
        int[] pad = theme.getImageRectangleTheme().getPaddings();
        item.getOrigin().setLocation(pad[SyntaxDisplayerTheme.LEFT], pad[SyntaxDisplayerTheme.TOP]);

        // посчитать размеры необходимой картинки
        Dimension itemSize = item.getSize();
        int imgWidth = (int)(itemSize.getWidth() + pad[SyntaxDisplayerTheme.LEFT] + pad[SyntaxDisplayerTheme.RIGHT]);
        int imgHeight = (int)(itemSize.getHeight() + pad[SyntaxDisplayerTheme.TOP] + pad[SyntaxDisplayerTheme.BOTTOM]);

        // создать картинку и отрисовать ей фон
        ImageAndGraphics source = createImageAndGraphics(imgWidth, imgHeight);
        log.debug(String.format("создано изображение, %dx%d пикселей", imgWidth, imgHeight));

        // включить сглаживание шрифтов
        // graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        theme.getImageRectangleTheme().render(source.graphics, new Dimension(imgWidth, imgHeight));

        for (CustomDrawer customDrawer : customDrawers) {
            customDrawer.setGraphics(source.graphics);
            customDrawer.willRender();
        }
        item.draw(source.graphics, customDrawers);
        for (CustomDrawer customDrawer : customDrawers) {
            customDrawer.didRender();
        }

        return source.image;
    }

    public void setVariantTreeBuilder(VariantTreeBuilder treeBuilder) {
        this.treeBuilder = treeBuilder;
    }

    public void setTheme(SyntaxDisplayerTheme theme) {
        this.theme = theme;
    }

    private ImageAndGraphics createImageAndGraphics(int width, int height) {
        ImageAndGraphics res = new ImageAndGraphics();

        if (USE_DISK_BACKED_IMAGE) {
            ColorModel cm = ColorModel.getRGBdefault();
            SampleModel sm = cm.createCompatibleSampleModel(IMAGE_TILE_WIDTH, IMAGE_TILE_HEIGHT);

            DiskMemImage image = new DiskMemImage(width, height, sm, cm);
            image.getTileCache().setMemoryCapacity(TILED_IMAGE_CACHE_SIZE);

            res.image = image;
            res.graphics = image.createGraphics();
        } else {
            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            res.image = image;
            res.graphics = image.createGraphics();
        }

        res.graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        res.graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        res.graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

        return res;
    }

    private BufferedImage getFailImage(String description) {
        if (failImage == null) {
            Font font = new Font("Arial", Font.PLAIN, 15);
            TextLayout layout = new TextLayout(description,
                    font,
                    DisplayableItem.dummyImageGraphics.getFontRenderContext());

            BufferedImage image = new BufferedImage(
                    (int)layout.getBounds().getWidth(),
                    (int)layout.getBounds().getHeight(),
                    BufferedImage.TYPE_INT_RGB);

            Graphics graphics = image.getGraphics();
            graphics.setFont(font);
            graphics.setColor(Color.RED);
            image.getGraphics().drawString(description, 0, 0);

            failImage = image;
        }

        return failImage;
    }

    private class ImageAndGraphics {
        RenderedImage image;
        Graphics2D graphics;
    }
}