import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.pdf.PdfDocument;
import android.graphics.pdf.PdfDocument.Page;
import android.graphics.pdf.PdfDocument.PageInfo;
import android.graphics.text.LineBreaker;
import android.os.Environment;
import android.text.Layout;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * <b style="color: red;">This class is designed to work with Android 33.</b>
 *
 * @author David Weber
 */
public class PdfDinA4Creator {
    private static class ContentBlock<Type> {
        public Type type;
        public Integer prefWidth;
        public Integer prefHeight;

        public ContentBlock(Type type) {
            this.type = type;
        }

        public ContentBlock(Type type, Integer prefWidth, Integer prefHeight) {
            this.type = type;
            this.prefWidth = prefWidth;
            this.prefHeight = prefHeight;
        }
    }

    private static final double ONE_CM_AS_INCH = 0.39370079;
    public static final int SIZE_OF_ONE_CM = (int) (ONE_CM_AS_INCH * 72);
    private final int widthDinA4 = (int) (8.27d * 72); // inches to points
    private final int heightDinA4 = (int) (11.69d * 72); // inches to points

    private int paddingLeftAndRight;
    private final List<ContentBlock<?>> contentBlocks;

    public PdfDinA4Creator() {
        contentBlocks = new ArrayList<>();
    }

    /**
     * Sets the left and right padding of the document.
     *
     * @param paddingLeftAndRight The used padding for left and right.
     * @return This PdfDinA4Creator.
     */
    public PdfDinA4Creator setPaddingLeftAndRight(int paddingLeftAndRight) {
        this.paddingLeftAndRight = paddingLeftAndRight;
        return this;
    }

    /**
     * Adds the given content as {@link ContentBlock} to the PDF.<br>
     * A {@link ContentBlock} inserts a line break after its end.<br>
     * The inserted content is left aligned and breaks when the document end is reached its line.
     *
     * @param content The content to add.
     * @return This PdfDinA4Creator.
     */
    public PdfDinA4Creator addContentBlock(CharSequence content) {
        if (content == null) {
            throw new NullPointerException("Content must not be null!");
        }
        TextPaint textPaint = new TextPaint();
        textPaint.setColor(Color.BLACK);
        textPaint.setTextSize(12);
        StaticLayout staticLayout = StaticLayout.Builder.obtain(
                        content,
                        0,
                        content.length(),
                        textPaint,
                        getDinA4WidthMinusPaddingLeftAndRight())
                .setText(content)
                .setAlignment(Layout.Alignment.ALIGN_NORMAL)
                .setLineSpacing(0.0f, 1.0f)
                .setIncludePad(false)
                .setBreakStrategy(LineBreaker.BREAK_STRATEGY_SIMPLE)
                .setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE)
                .build();
        contentBlocks.add(new ContentBlock<>(staticLayout));
        return this;
    }

    /**
     * Adds the given content as {@link ContentBlock} to the PDF.<br>
     * A {@link ContentBlock} inserts a line break after its end.<br>
     * By defining the arguments "prefWidth" and "prefHeight", the content is scaled by respecting its width-height-aspect-ratio.
     * If the width or height is bigger than the max available size, the content is scaled to the max available size.
     *
     * @param content    The content to add.
     * @param prefWidth  The preferred width to scale the content to.
     * @param prefHeight The preferred height to scale the content to.
     * @return This PdfDinA4Creator.
     */
    public PdfDinA4Creator addContentBlock(Bitmap content, Integer prefWidth, Integer prefHeight) {
        if (content == null) {
            throw new NullPointerException("Content must not be null!");
        }

        if (content.getHeight() > content.getWidth()) {
            content = rescaleBitmapByPrefWidth(content, prefWidth);
            content = rescaleBitmapByPrefHeight(content, prefHeight);
        } else {
            content = rescaleBitmapByPrefHeight(content, prefHeight);
            content = rescaleBitmapByPrefWidth(content, prefWidth);
        }

        if (content.getHeight() > heightDinA4) {
            throw new RuntimeException("The Bitmap is to big to fit on a single DIN A4 sheet. Either implement logic here or don't allow it.");
        }
        if (content.getWidth() > widthDinA4) {
            throw new RuntimeException("The Bitmap is to big to fit on a single DIN A4 sheet. Either implement logic here or don't allow it.");
        }

        contentBlocks.add(new ContentBlock<>(content, prefWidth, prefHeight));
        return this;
    }

    /**
     * Adds the given content as {@link ContentBlock} to the PDF.<br>
     * A {@link ContentBlock} inserts a line break after its end.<br>
     * By defining the arguments "prefWidth" and "prefHeight", the content is scaled by respecting its width-height-aspect-ratio.
     * If the width or height is bigger than the max available size, the content is scaled to the max available size.
     *
     * @param content    The content to add.
     * @param prefWidth  The preferred width to scale the content to.
     * @param prefHeight The preferred height to scale the content to.
     * @return This PdfDinA4Creator.
     */
    public PdfDinA4Creator addContentBlock(Drawable content, Integer prefWidth, Integer prefHeight) {
        if (content == null) {
            throw new NullPointerException("Content must not be null!");
        }
        return addContentBlock(convertDrawableToBitmap(content), prefWidth, prefHeight);
    }

    /**
     * Creates the PDF-Document.
     *
     * @return The created PDF-Document.
     */
    public PdfDocument createAndGet() {
        PdfDocument document = new PdfDocument();
        Page currentPage = initNextPage(document, null, widthDinA4, heightDinA4);

        int currentCoordinateSystemStartY = 0;
        for (ContentBlock<?> contentBlock : contentBlocks) {
            if (contentBlock.type instanceof StaticLayout) {
                StaticLayout layout = (StaticLayout) contentBlock.type;
                if (layout.getHeight() > heightDinA4) {
                    throw new RuntimeException("The StaticLayout representing is to big to fit on a single DIN A4 sheet. Please split it into several ContentBlocks.");
                }
                if (currentCoordinateSystemStartY + layout.getHeight() > heightDinA4) { // layout passt nicht mehr komplett auf die aktuelle Seite drauf
                    currentPage = initNextPage(document, currentPage, widthDinA4, heightDinA4);
                    currentCoordinateSystemStartY = 0;
                }

                currentPage.getCanvas().translate(paddingLeftAndRight, 0);
                layout.draw(currentPage.getCanvas());
                currentPage.getCanvas().translate(-paddingLeftAndRight, layout.getHeight());
                currentCoordinateSystemStartY += layout.getHeight();
                continue;
            }
            if (contentBlock.type instanceof Bitmap) {
                Bitmap bitmap = (Bitmap) contentBlock.type;

                Paint paint = new Paint();
                paint.setAntiAlias(true);
                paint.setFilterBitmap(true);
                paint.setDither(true);

                if (currentCoordinateSystemStartY + bitmap.getHeight() > heightDinA4) { // layout passt nicht mehr komplett auf die aktuelle Seite drauf
                    currentPage = initNextPage(document, currentPage, widthDinA4, heightDinA4);
                    currentCoordinateSystemStartY = 0;
                }

                currentPage.getCanvas().translate(paddingLeftAndRight, 0);
                currentPage.getCanvas().drawBitmap(bitmap, 0, 0, paint);
                currentPage.getCanvas().translate(-paddingLeftAndRight, bitmap.getHeight());
                currentCoordinateSystemStartY += bitmap.getHeight();
            }
        }
        document.finishPage(currentPage);
        return document;
    }

    public static void savePdfIntoDownloadsDirectory(String fileName, PdfDocument pdfDocument) throws IOException {
        String filePathInDownloadsDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getPath() + "/" + fileName;
        File file = new File(filePathInDownloadsDir);
        pdfDocument.writeTo(new FileOutputStream(file));
        pdfDocument.close();
    }

    @SuppressWarnings("PointlessArithmeticExpression")
    private int getDinA4HeightMinusPaddingTopAndBottom() {
        return heightDinA4 - 0 * 2;
    }

    private int getDinA4WidthMinusPaddingLeftAndRight() {
        return widthDinA4 - paddingLeftAndRight * 2;
    }

    @SuppressWarnings("SameParameterValue")
    private Page initNextPage(PdfDocument document, Page currentPage, int width, int height) {
        if (currentPage != null) {
            document.finishPage(currentPage);
        }
        Page nextPage = document.startPage(new PageInfo.Builder(width, height, document.getPages().size() + 1).create());
        nextPage.getCanvas().save();
        return nextPage;
    }

    private Bitmap convertDrawableToBitmap(Drawable drawable) {
        if (drawable instanceof BitmapDrawable) {
            return ((BitmapDrawable) drawable).getBitmap();
        }

        Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
        drawable.draw(canvas);

        return bitmap;
    }

    private Bitmap scaleProportionalToNewHeight(Bitmap bitmap, int newHeight) {
        float aspectRatio = bitmap.getWidth() / (float) bitmap.getHeight();
        int width = Math.round(newHeight * aspectRatio);
        return Bitmap.createScaledBitmap(bitmap, width, newHeight, true);
    }

    private Bitmap scaleProportionalToNewWidth(Bitmap bitmap, int newWidth) {
        float aspectRatio = bitmap.getWidth() / (float) bitmap.getHeight();
        int height = Math.round(newWidth / aspectRatio);
        return Bitmap.createScaledBitmap(bitmap, newWidth, height, true);
    }

    private Bitmap rescaleBitmapByPrefHeight(Bitmap bitmap, Integer prefHeight) {
        if (prefHeight == null) {
            if (bitmap.getHeight() > getDinA4HeightMinusPaddingTopAndBottom()) {
                bitmap = scaleProportionalToNewHeight(bitmap, getDinA4HeightMinusPaddingTopAndBottom());
            }
        } else {
            if (prefHeight > getDinA4HeightMinusPaddingTopAndBottom()) {
                Log.w("PdfDinA4Creator", "contentBlock.prefHeight is not null, but it is bigger than the available space. Using the max. available space.");
                bitmap = scaleProportionalToNewHeight(bitmap, getDinA4HeightMinusPaddingTopAndBottom());
            } else {
                bitmap = scaleProportionalToNewHeight(bitmap, prefHeight);
            }
        }
        return bitmap;
    }

    private Bitmap rescaleBitmapByPrefWidth(Bitmap bitmap, Integer prefWidth) {
        if (prefWidth == null) {
            if (bitmap.getWidth() > getDinA4WidthMinusPaddingLeftAndRight()) {
                bitmap = scaleProportionalToNewWidth(bitmap, getDinA4WidthMinusPaddingLeftAndRight());
            }
        } else {
            if (prefWidth > getDinA4WidthMinusPaddingLeftAndRight()) {
                Log.w("PdfDinA4Creator", "contentBlock.prefWidth is not null, but it is bigger than the available space. Using the max. available space.");
                bitmap = scaleProportionalToNewWidth(bitmap, getDinA4WidthMinusPaddingLeftAndRight());
            } else {
                bitmap = scaleProportionalToNewWidth(bitmap, prefWidth);
            }
        }
        return bitmap;
    }

}