// Definitions.
import { ImageSource as ImageSourceDefinition } from ".";
import { ImageAsset } from "../image-asset";
import * as httpModule from "../http";

// Types.
import { path as fsPath, knownFolders } from "../file-system";
import { isFileOrResourcePath, RESOURCE_PREFIX, layout } from "../utils/utils";
import { getNativeApplication } from "../application";
import { Font } from "../ui/styling/font";
import { Color } from "../color";

import { getScaledDimensions } from "./image-source-common";

export { isFileOrResourcePath };

let http: typeof httpModule;
function ensureHttp() {
    if (!http) {
        http = require("../http");
    }
}

let application: android.app.Application;
let resources: android.content.res.Resources;

function getApplication() {
    if (!application) {
        application = (<android.app.Application>getNativeApplication());
    }

    return application;
}

function getResources() {
    if (!resources) {
        resources = getApplication().getResources();
    }

    return resources;
}

export class ImageSource implements ImageSourceDefinition {
    public android: android.graphics.Bitmap;
    public ios: UIImage;

    public get height(): number {
        if (this.android) {
            return this.android.getHeight();
        }

        return NaN;
    }

    public get width(): number {
        if (this.android) {
            return this.android.getWidth();
        }

        return NaN;
    }

    private _rotationAngle: number;
    public get rotationAngle(): number {
        return this._rotationAngle;
    }

    public set rotationAngle(value: number) {
        this._rotationAngle = value;
    }

    constructor(nativeSource?: any) {
        if (nativeSource) {
            this.setNativeSource(nativeSource);
        }
    }

    static fromAsset(asset: ImageAsset): Promise<ImageSource> {
        return new Promise<ImageSource>((resolve, reject) => {
            asset.getImageAsync((image, err) => {
                if (image) {
                    resolve(new ImageSource(image));
                } else {
                    reject(err);
                }
            });
        });
    }

    static fromUrl(url: string): Promise<ImageSourceDefinition> {
        ensureHttp();

        return http.getImage(url);
    }

    static fromResourceSync(name: string): ImageSource {
        const res = getResources();
        if (res) {
            const identifier: number = res.getIdentifier(name, "drawable", getApplication().getPackageName());
            if (0 < identifier) {
                // Load BitmapDrawable with getDrawable to make use of Android internal caching
                const bitmapDrawable = <android.graphics.drawable.BitmapDrawable>res.getDrawable(identifier);
                if (bitmapDrawable && bitmapDrawable.getBitmap) {
                    return new ImageSource(bitmapDrawable.getBitmap());
                }
            }
        }

        return null;
    }
    static fromResource(name: string): Promise<ImageSource> {
        return new Promise<ImageSource>((resolve, reject) => {
            resolve(ImageSource.fromResourceSync(name));
        });
    }

    static fromFileSync(path: string): ImageSource {
        let fileName = typeof path === "string" ? path.trim() : "";
        if (fileName.indexOf("~/") === 0) {
            fileName = fsPath.join(knownFolders.currentApp().path, fileName.replace("~/", ""));
        }

        const bitmap = android.graphics.BitmapFactory.decodeFile(fileName, null);
        if (bitmap) {
            const result = new ImageSource(bitmap);
            result.rotationAngle = getRotationAngleFromFile(fileName);

            return result;
        } else {
            return null;
        }
    }

    static fromFile(path: string): Promise<ImageSource> {
        return new Promise<ImageSource>((resolve, reject) => {
            resolve(ImageSource.fromFileSync(path));
        });
    }

    static fromFileOrResourceSync(path: string): ImageSource {
        if (!isFileOrResourcePath(path)) {
            throw new Error(`${path} is not a valid file or resource.`);
        }

        if (path.indexOf(RESOURCE_PREFIX) === 0) {
            return ImageSource.fromResourceSync(path.substr(RESOURCE_PREFIX.length));
        }

        return ImageSource.fromFileSync(path);
    }

    static fromDataSync(data: any): ImageSource {
        const bitmap = android.graphics.BitmapFactory.decodeStream(data);

        return bitmap ? new ImageSource(bitmap) : null;
    }

    static fromData(data: any): Promise<ImageSource> {
        return new Promise<ImageSource>((resolve, reject) => {
            resolve(ImageSource.fromDataSync(data));
        });
    }

    static fromBase64Sync(source: string): ImageSource {
        let bitmap: android.graphics.Bitmap;

        if (typeof source === "string") {
            const bytes = android.util.Base64.decode(source, android.util.Base64.DEFAULT);
            bitmap = android.graphics.BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
        }

        return bitmap ? new ImageSource(bitmap) : null;
    }
    static fromBase64(source: string): Promise<ImageSource> {
        return new Promise<ImageSource>((resolve, reject) => {
            resolve(ImageSource.fromBase64Sync(source));
        });
    }

    static fromFontIconCodeSync(source: string, font: Font, color: Color): ImageSource {
        font = font || Font.default;
        const paint = new android.graphics.Paint();
        paint.setTypeface(font.getAndroidTypeface());
        paint.setAntiAlias(true);

        if (color) {
            paint.setColor(color.android);
        }

        let fontSize = layout.toDevicePixels(font.fontSize);
        if (!fontSize) {
            // TODO: Consider making 36 font size as default for optimal look on TabView and ActionBar
            fontSize = paint.getTextSize();
        }

        const density = layout.getDisplayDensity();
        const scaledFontSize = fontSize * density;
        paint.setTextSize(scaledFontSize);

        const textBounds = new android.graphics.Rect();
        paint.getTextBounds(source, 0, source.length, textBounds);

        const textWidth = textBounds.width();
        const textHeight = textBounds.height();
        if (textWidth > 0 && textHeight > 0) {
            const bitmap = android.graphics.Bitmap
                .createBitmap(
                    textWidth,
                    textHeight,
                    android.graphics.Bitmap.Config.ARGB_8888
                );

            const canvas = new android.graphics.Canvas(bitmap);
            canvas.drawText(source, -textBounds.left, -textBounds.top, paint);

            return new ImageSource(bitmap);
        }

        return null;
    }

    public fromAsset(asset: ImageAsset): Promise<ImageSource> {
        console.log("fromAsset() is deprecated. Use ImageSource.fromAsset() instead.");

        return ImageSource.fromAsset(asset)
            .then(imgSource => {
                this.setNativeSource(imgSource.android);

                return this;
            });
    }

    public loadFromResource(name: string): boolean {
        console.log("fromResource() and loadFromResource() are deprecated. Use ImageSource.fromResource[Sync]() instead.");

        const imgSource = ImageSource.fromResourceSync(name);
        this.android = imgSource ? imgSource.android : null;

        return !!this.android;
    }

    public fromResource(name: string): Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            resolve(this.loadFromResource(name));
        });
    }

    public loadFromFile(path: string): boolean {
        console.log("fromFile() and loadFromFile() are deprecated. Use ImageSource.fromFile[Sync]() instead.");

        const imgSource = ImageSource.fromFileSync(path);
        this.android = imgSource ? imgSource.android : null;

        return !!this.android;
    }

    public fromFile(path: string): Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            resolve(this.loadFromFile(path));
        });
    }

    public loadFromData(data: any): boolean {
        console.log("fromData() and loadFromData() are deprecated. Use ImageSource.fromData[Sync]() instead.");

        const imgSource = ImageSource.fromDataSync(data);
        this.android = imgSource ? imgSource.android : null;

        return !!this.android;
    }

    public fromData(data: any): Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            resolve(this.loadFromData(data));
        });
    }

    public loadFromBase64(source: string): boolean {
        console.log("fromBase64() and loadFromBase64() are deprecated. Use ImageSource.fromBase64[Sync]() instead.");

        const imgSource = ImageSource.fromBase64Sync(source);
        this.android = imgSource ? imgSource.android : null;

        return !!this.android;
    }

    public fromBase64(data: any): Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            resolve(this.loadFromBase64(data));
        });
    }

    public loadFromFontIconCode(source: string, font: Font, color: Color): boolean {
        console.log("loadFromFontIconCode() is deprecated. Use ImageSource.fromFontIconCodeSync() instead.");

        const imgSource = ImageSource.fromFontIconCodeSync(source, font, color);
        this.android = imgSource ? imgSource.android : null;

        return !!this.android;
    }

    public setNativeSource(source: any): void {
        if (source && !(source instanceof android.graphics.Bitmap)) {
            throw new Error("The method setNativeSource() expects android.graphics.Bitmap instance.");
        }
        this.android = source;
    }

    public saveToFile(path: string, format: "png" | "jpeg" | "jpg", quality = 100): boolean {
        if (!this.android) {
            return false;
        }

        const targetFormat = getTargetFormat(format);

        // TODO add exception handling
        const outputStream = new java.io.BufferedOutputStream(new java.io.FileOutputStream(path));

        const res = this.android.compress(targetFormat, quality, outputStream);
        outputStream.close();

        return res;
    }

    public toBase64String(format: "png" | "jpeg" | "jpg", quality = 100): string {
        if (!this.android) {
            return null;
        }

        const targetFormat = getTargetFormat(format);

        const outputStream = new java.io.ByteArrayOutputStream();
        const base64Stream = new android.util.Base64OutputStream(outputStream, android.util.Base64.NO_WRAP);

        this.android.compress(targetFormat, quality, base64Stream);

        base64Stream.close();
        outputStream.close();

        return outputStream.toString();
    }

    public resize(maxSize: number, options?: any): ImageSource {
        const dim = getScaledDimensions(this.android.getWidth(), this.android.getHeight(), maxSize);
        const bm: android.graphics.Bitmap = android.graphics.Bitmap.createScaledBitmap(
            this.android,
            dim.width,
            dim.height,
            options && options.filter
        );
        
        return new ImageSource(bm);
    }
}

function getTargetFormat(format: "png" | "jpeg" | "jpg"): android.graphics.Bitmap.CompressFormat {
    switch (format) {
        case "jpeg":
        case "jpg":
            return android.graphics.Bitmap.CompressFormat.JPEG;
        default:
            return android.graphics.Bitmap.CompressFormat.PNG;
    }
}

function getRotationAngleFromFile(filename: string): number {
    let result = 0;
    const ei = new android.media.ExifInterface(filename);
    const orientation = ei.getAttributeInt(android.media.ExifInterface.TAG_ORIENTATION, android.media.ExifInterface.ORIENTATION_NORMAL);

    switch (orientation) {
        case android.media.ExifInterface.ORIENTATION_ROTATE_90:
            result = 90;
            break;
        case android.media.ExifInterface.ORIENTATION_ROTATE_180:
            result = 180;
            break;
        case android.media.ExifInterface.ORIENTATION_ROTATE_270:
            result = 270;
            break;
    }

    return result;
}

export function fromAsset(asset: ImageAsset): Promise<ImageSource> {
    console.log("fromAsset() is deprecated. Use ImageSource.fromAsset() instead.");

    return ImageSource.fromAsset(asset);
}

export function fromResource(name: string): ImageSource {
    console.log("fromResource() is deprecated. Use ImageSource.fromResourceSync() instead.");

    return ImageSource.fromResourceSync(name);
}

export function fromFile(path: string): ImageSource {
    console.log("fromFile() is deprecated. Use ImageSource.fromFileSync() instead.");

    return ImageSource.fromFileSync(path);
}

export function fromData(data: any): ImageSource {
    console.log("fromData() is deprecated. Use ImageSource.fromDataSync() instead.");

    return ImageSource.fromDataSync(data);
}

export function fromFontIconCode(source: string, font: Font, color: Color): ImageSource {
    console.log("fromFontIconCode() is deprecated. Use ImageSource.fromFontIconCodeSync() instead.");

    return ImageSource.fromFontIconCodeSync(source, font, color);
}

export function fromBase64(source: string): ImageSource {
    console.log("fromBase64() is deprecated. Use ImageSource.fromBase64Sync() instead.");

    return ImageSource.fromBase64Sync(source);
}

export function fromNativeSource(nativeSource: any): ImageSource {
    console.log("fromNativeSource() is deprecated. Use ImageSource constructor instead.");

    return new ImageSource(nativeSource);
}

export function fromUrl(url: string): Promise<ImageSourceDefinition> {
    console.log("fromUrl() is deprecated. Use ImageSource.fromUrl() instead.");

    return ImageSource.fromUrl(url);
}

export function fromFileOrResource(path: string): ImageSource {
    console.log("fromFileOrResource() is deprecated. Use ImageSource.fromFileOrResourceSync() instead.");

    return ImageSource.fromFileOrResourceSync(path);
}