package nodebox.graphics;

import nodebox.util.MathUtils;

import javax.imageio.ImageIO;
import javax.management.RuntimeErrorException;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.*;

public class Image extends AbstractGrob {

    private float x, y;
    private float desiredWidth, desiredHeight;
    private float alpha = 1.0F;

    private BufferedImage image;
    private static BufferedImage blankImage = new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY);
    public static final String BLANK_IMAGE = "__blank";

    public Image() {
        this(new File(BLANK_IMAGE));
    }

    public Image(File file) {
        if (file == null || file.getPath().equals(BLANK_IMAGE)) {
            image = blankImage;
        } else {
            try {
                image = ImageIO.read(file);
            } catch (IOException e) {
                throw new RuntimeErrorException(null, "Could not read image " + file);
            }
        }
    }

    public Image(String fname) {
        this(new File(fname));
    }

    public Image(String fname, float cx, float cy) {
        this(new File(fname));
        this.x = cx;
        this.y = cy;
    }

    public Image(BufferedImage image) {
        this.image = image;
    }

    public Image(Image other) {
        super(other);
        this.x = other.x;
        this.y = other.y;
        this.desiredWidth = other.desiredWidth;
        this.desiredHeight = other.desiredHeight;
        this.alpha = other.alpha;
        this.image = other.image;
    }

    public static Image fromData(byte[] data) {
        InputStream istream = new BufferedInputStream(new ByteArrayInputStream(data));
        try {
            return new Image(ImageIO.read(istream));
        } catch (IOException e) {
            throw new RuntimeErrorException(null, "Could not read image data.");
        }
    }

    //// Attribute access ////

    public float getOriginalWidth() {
        if (image == null) return 0;
        return image.getWidth();
    }

    public float getOriginalHeight() {
        if (image == null) return 0;
        return image.getHeight();
    }

    public float getWidth() {
        return getOriginalWidth() * getScaleFactor();
    }

    public void setWidth(float width) {
        this.desiredWidth = width;
    }

    public float getHeight() {
        return getOriginalHeight() * getScaleFactor();
    }

    public void setHeight(float height) {
        this.desiredHeight = height;
    }

    public float getX() {
        return x;
    }

    public void setX(float x) {
        this.x = x;
    }

    public float getY() {
        return y;
    }

    public void setY(float y) {
        this.y = y;
    }

    public float getAlpha() {
        return alpha;
    }

    public void setAlpha(float alpha) {
        this.alpha = alpha;
    }

    public BufferedImage getAwtImage() {
        return image;
    }

    public Size getSize() {
        return new Size(image.getWidth(), image.getHeight());
    }

    //// Transformations ////

    protected void setupTransform(Graphics2D g) {
        saveTransform(g);
        AffineTransform trans = g.getTransform();
        trans.concatenate(getTransform().getAffineTransform());
        g.setTransform(trans);
    }

    //// Grob support ////


    public boolean isEmpty() {
        return image == null || image.getWidth() == 0 || image.getHeight() == 0;
    }

    public Rect getBounds() {
        if (image == null) return new Rect();
        float factor = getScaleFactor();
        float finalWidth = image.getWidth() * factor;
        float finalHeight = image.getHeight() * factor;
        return new Rect(x - finalWidth / 2, y - finalHeight / 2, finalWidth, finalHeight);
    }

    public float getScaleFactor() {
        if (desiredWidth != 0 || desiredHeight != 0) {
            float srcW = image.getWidth();
            float srcH = image.getHeight();
            if (desiredWidth != 0 && desiredHeight != 0) {
                // Both width and height were given, constrain to smallest
                return Math.min(desiredWidth / srcW, desiredHeight / srcH);
            } else if (desiredWidth != 0) {
                return desiredWidth / srcW;
            } else {
                return desiredHeight / srcH;
            }
        } else {
            return 1;
        }
    }

    public void draw(Graphics2D g) {
        setupTransform(g);
        // You can only position an image using an affine transformation.
        // We use the transformation to translate the image to the specified
        // position, and scale it according to the given width and height.
        Transform imageTrans = new Transform();
        // Move to the image position. Convert x, y, which are centered coordinates,
        // to "real" coordinates. 
        float factor = getScaleFactor();
        float finalWidth = image.getWidth() * factor;
        float finalHeight = image.getHeight() * factor;
        imageTrans.translate(x - finalWidth / 2, y - finalHeight / 2);
        // Scaling only applies to image that have their desired width and/or height set.
        // However, getScaleFactor return 1 if height/width are not set, in effect negating
        // the effect of the scale.
        imageTrans.scale(getScaleFactor());
        float a = MathUtils.clamp(alpha);
        Composite composite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) a);
        Composite oldComposite = g.getComposite();
        g.setComposite(composite);
        g.drawRenderedImage(image, imageTrans.getAffineTransform());
        g.setComposite(oldComposite);
        restoreTransform(g);
    }


    public Image clone() {
        return new Image(this);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Image)) return false;
        Image other = (Image) obj;
        return this.x == other.x
                && this.y == other.y
                && this.desiredWidth == other.desiredWidth
                && this.desiredHeight == other.desiredHeight
                && this.alpha == other.alpha
                && this.image.equals(other.image)
                && super.equals(other);
    }

    @Override
    public String toString() {
        return "<Image (" + getWidth() + ", " + getHeight() + ")>";
    }
}