/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.print.pdf;

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Rect;

import dalvik.system.CloseGuard;

import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * <p>
 * This class enables generating a PDF document from native Android content. You
 * open a new document and then for every page you want to add you start a page,
 * write content to the page, and finish the page. After you are done with all
 * pages, you write the document to an output stream and close the document.
 * After a document is closed you should not use it anymore.
 * </p>
 * <p>
 * A typical use of the APIs looks like this:
 * </p>
 * <pre>
 * // open a new document
 * PdfDocument document = PdfDocument.open();
 *
 * // crate a page description
 * PageInfo pageInfo = new PageInfo.Builder(new Rect(0, 0, 100, 100), 1, 300).create();
 *
 * // start a page
 * Page page = document.startPage(pageInfo);
 *
 * // draw something on the page
 * View content = getContentView();
 * content.draw(page.getCanvas());
 *
 * // finish the page
 * document.finishPage(page);
 * . . .
 * // add more pages
 * . . .
 * // write the document content
 * document.writeTo(getOutputStream());
 *
 * //close the document
 * document.close();
 * </pre>
 */
public final class PdfDocument {

    private final byte[] mChunk = new byte[4096];

    private final CloseGuard mCloseGuard = CloseGuard.get();

    private final List<PageInfo> mPages = new ArrayList<PageInfo>();

    private int mNativeDocument;

    private Page mCurrentPage;

    /**
     * Opens a new document.
     * <p>
     * <strong>Note:</strong> You must close the document after you are
     * done by calling {@link #close()}
     * </p>
     *
     * @return The document.
     *
     * @see #close()
     */
    public static PdfDocument open() {
        return new PdfDocument();
    }

    /**
     * Creates a new instance.
     */
    private PdfDocument() {
        mNativeDocument = nativeCreateDocument();
        mCloseGuard.open("close");
    }

    /**
     * Starts a page using the provided {@link PageInfo}. After the page
     * is created you can draw arbitrary content on the page's canvas which
     * you can get by calling {@link Page#getCanvas()}. After you are done
     * drawing the content you should finish the page by calling
     * {@link #finishPage(Page)}. After the page is finished you should
     * no longer access the page or its canvas.
     * <p>
     * <strong>Note:</strong> Do not call this method after {@link #close()}.
     * </p>
     *
     * @param pageInfo The page info.
     * @return A blank page.
     *
     * @see #finishPage(Page)
     */
    public Page startPage(PageInfo pageInfo) {
        throwIfClosed();
        if (pageInfo == null) {
            throw new IllegalArgumentException("page cannot be null!");
        }
        if (mCurrentPage != null) {
            throw new IllegalStateException("Previous page not finished!");
        }
        Canvas canvas = new PdfCanvas(nativeCreatePage(pageInfo.mPageSize,
                pageInfo.mContentSize, pageInfo.mInitialTransform.native_instance),
                pageInfo.mDensity);
        mCurrentPage = new Page(canvas, pageInfo);
        return mCurrentPage;
    }

    /**
     * Finishes a started page. You should always finish the last started page.
     * <p>
     * <strong>Note:</strong> Do not call this method after {@link #close()}.
     * </p>
     *
     * @param page The page.
     *
     * @see #startPage(PageInfo)
     */
    public void finishPage(Page page) {
        throwIfClosed();
        if (page == null) {
            throw new IllegalArgumentException("page cannot be null");
        }
        if (page != mCurrentPage) {
            throw new IllegalStateException("invalid page");
        }
        mPages.add(page.getInfo());
        mCurrentPage = null;
        nativeAppendPage(mNativeDocument, page.mCanvas.mNativeCanvas);
        page.finish();
    }

    /**
     * Writes the document to an output stream.
     * <p>
     * <strong>Note:</strong> Do not call this method after {@link #close()}.
     * </p>
     *
     * @param out The output stream.
     */
    public void writeTo(OutputStream out) {
        throwIfClosed();
        if (out == null) {
            throw new IllegalArgumentException("out cannot be null!");
        }
        nativeWriteTo(mNativeDocument, out, mChunk);
    }

    /**
     * Gets the pages of the document.
     *
     * @return The pages.
     */
    public List<PageInfo> getPages() {
        return Collections.unmodifiableList(mPages);
    }

    /**
     * Closes this document. This method should be called after you
     * are done working with the document. After this call the document
     * is considered closed and none of its methods should be called.
     */
    public void close() {
        dispose();
    }

    @Override
    protected void finalize() throws Throwable {
        try {
            mCloseGuard.warnIfOpen();
            dispose();
        } finally {
            super.finalize();
        }
    }

    private void dispose() {
        if (mNativeDocument != 0) {
            nativeFinalize(mNativeDocument);
            mCloseGuard.close();
            mNativeDocument = 0;
        }
    }

    /**
     * Throws an exception if the document is already closed.
     */
    private void throwIfClosed() {
        if (mNativeDocument == 0) {
            throw new IllegalStateException("document is closed!");
        }
    }

    private native int nativeCreateDocument();

    private native void nativeFinalize(int document);

    private native void nativeAppendPage(int document, int page);

    private native void nativeWriteTo(int document, OutputStream out, byte[] chunk);

    private static native int nativeCreatePage(Rect pageSize,
            Rect contentSize, int nativeMatrix);


    private final class PdfCanvas extends Canvas {

        public PdfCanvas(int nativeCanvas, int density) {
            super(nativeCanvas);
            super.setDensity(density);
        }

        @Override
        public void setBitmap(Bitmap bitmap) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void setDensity(int density) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void setScreenDensity(int density) {
            throw new UnsupportedOperationException();
        }
    }

    /**
     * This class represents meta-data that describes a PDF {@link Page}.
     */
    public static final class PageInfo {
        private Rect mPageSize;
        private Rect mContentSize;
        private Matrix mInitialTransform;
        private int mPageNumber;
        private int mDensity;

        /**
         * Creates a new instance.
         */
        private PageInfo() {
            /* do nothing */
        }

        /**
         * Gets the page size in pixels.
         *
         * @return The page size.
         */
        public Rect getPageSize() {
            return mPageSize;
        }

        /**
         * Get the content size in pixels.
         *
         * @return The content size.
         */
        public Rect getContentSize() {
            return mContentSize;
        }

        /**
         * Gets the initial transform which is applied to the page. This may be
         * useful to move the origin to account for a margin, apply scale, or
         * apply a rotation.
         *
         * @return The initial transform.
         */
        public Matrix getInitialTransform() {
            return mInitialTransform;
        }

        /**
         * Gets the page number.
         *
         * @return The page number.
         */
        public int getPageNumber() {
            return mPageNumber;
        }

        /**
         * Gets the density of the page in DPI.
         *
         * @return The density.
         */
        public int getDesity() {
            return mDensity;
        }

        /**
         * Builder for creating a {@link PageInfo}.
         */
        public static final class Builder {
            private final PageInfo mPageInfo = new PageInfo();

            /**
             * Creates a new builder with the mandatory page info attributes.
             *
             * @param pageSize The page size in pixels.
             * @param pageNumber The page number.
             * @param density The page density in DPI.
             */
            public Builder(Rect pageSize, int pageNumber, int density) {
                if (pageSize.width() == 0 || pageSize.height() == 0) {
                    throw new IllegalArgumentException("page width and height" +
                            " must be greater than zero!");
                }
                if (pageNumber < 0) {
                    throw new IllegalArgumentException("pageNumber cannot be less than zero!");
                }
                if (density <= 0) {
                    throw new IllegalArgumentException("density must be greater than zero!");
                }
                mPageInfo.mPageSize = pageSize;
                mPageInfo.mPageNumber = pageNumber;
                mPageInfo.mDensity = density;
            }

            /**
             * Sets the content size in pixels.
             *
             * @param contentSize The content size.
             */
            public Builder setContentSize(Rect contentSize) {
                Rect pageSize = mPageInfo.mPageSize;
                if (contentSize != null && (pageSize.left > contentSize.left
                        || pageSize.top > contentSize.top
                        || pageSize.right < contentSize.right
                        || pageSize.bottom < contentSize.bottom)) {
                    throw new IllegalArgumentException("contentSize does not fit the pageSize!");
                }
                mPageInfo.mContentSize = contentSize;
                return this;
            }

            /**
             * Sets the initial transform which is applied to the page. This may be
             * useful to move the origin to account for a margin, apply scale, or
             * apply a rotation.
             *
             * @param transform The initial transform.
             */
            public Builder setInitialTransform(Matrix transform) {
                mPageInfo.mInitialTransform = transform;
                return this;
            }

            /**
             * Creates a new {@link PageInfo}.
             *
             * @return The new instance.
             */
            public PageInfo create() {
                if (mPageInfo.mContentSize == null) {
                    mPageInfo.mContentSize = mPageInfo.mPageSize;
                }
                if (mPageInfo.mInitialTransform == null) {
                    mPageInfo.mInitialTransform = new Matrix();
                }
                return mPageInfo;
            }
        }
    }

    /**
     * This class represents a PDF document page. It has associated
     * a canvas on which you can draw content and is acquired by a
     * call to {@link #getCanvas()}. It also has associated a
     * {@link PageInfo} instance that describes its attributes.
     */
    public static final class Page {
        private final PageInfo mPageInfo;
        private Canvas mCanvas;

        /**
         * Creates a new instance.
         *
         * @param canvas The canvas of the page.
         * @param pageInfo The info with meta-data.
         */
        private Page(Canvas canvas, PageInfo pageInfo) {
            mCanvas = canvas;
            mPageInfo = pageInfo;
        }

        /**
         * Gets the {@link Canvas} of the page.
         *
         * @return The canvas if the page is not finished, null otherwise.
         *
         * @see PdfDocument#finishPage(Page)
         */
        public Canvas getCanvas() {
            return mCanvas;
        }

        /**
         * Gets the {@link PageInfo} with meta-data for the page.
         *
         * @return The page info.
         *
         * @see PdfDocument#finishPage(Page)
         */
        public PageInfo getInfo() {
            return mPageInfo;
        }

        private void finish() {
            if (mCanvas != null) {
                mCanvas.release();
                mCanvas = null;
            }
        }
    }
}