package com.tkraindesigns.gameutility;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.RectF;

import java.util.ArrayList;

/**
 * Holds an array of {@link Bitmap} for animations.  Used to select specific graphics.  Implements 
 * methods to scale and flip bitmaps as they are loaded.
 */
public class BitmapBuffer {

    /**
     * The actual buffer
     */
    private ArrayList<Bitmap> buffer = new ArrayList<>();

    /**
     * Holds an array of {@link Bitmap} for animations.  Used to select specific graphics.  Implements 
     * methods to scale and flip bitmaps as they are loaded.
     */
    public BitmapBuffer() {
        super();
        buffer.clear();
    }

    /**
     * Adds a {@link Bitmap} to the existing buffer, read from the system resources.
     * @param context - Theapplication Context provided to your custom SurfaceView
     * @param resid - The R.drawable.bitmapname
     * @return An integer index into the buffer.
     */
    @SuppressWarnings("unused")
    public int AddBitMapFromRes(Context context,int resid) {
        Bitmap tempbitmap;
        tempbitmap= BitmapFactory.decodeResource(context.getResources(),resid);
        buffer.add(tempbitmap);
        return buffer.size()-1;

    }

    /**
     * Adds bitmap to the existing buffer from R.drawable.resourcename.  Scales image to x/y
     * @param context The application context provided to your custom SurfaceView
     * @param resid the R.drawable.bitmapname
     * @param x Width to scale image
     * @param y Height to scale image
     * @return An integer index into the buffer.
     */
    @SuppressWarnings("unused")
    public int AddandScaleBitmapFromRes(Context context, int resid,int x, int y) {
        Bitmap tempbitmap;
        tempbitmap= BitmapFactory.decodeResource(context.getResources(),resid);
        if (x>0)      //only rescale if it's valid to do so
        {
            if (y > 0) {
                tempbitmap = Bitmap.createScaledBitmap(tempbitmap, x, y, true);
            }
        }
        buffer.add(tempbitmap);
        return buffer.size()-1;
    }

    /**
     * Adds bitmap to the existing buffer from R.drawable.resourcename.  Scales image to x/y
     * and flips the image right to left.  Useful for creating direction.
     * @param context The application context provided to your custom SurfaceView
     * @param resid the R.drawable.bitmapname
     * @param x Width to scale image
     * @param y Height to scale image
     * @return An integer index into the buffer.
     */
    @SuppressWarnings("unused")
    public int AddandScaleFlippedBitmapFromRes(Context context,int resid,int x, int y) {
        Bitmap tempbitmap;
        Matrix matrix = new Matrix();
        matrix.setScale(-1,1);
        tempbitmap=BitmapFactory.decodeResource(context.getResources(),resid);
        if (x>0) {
            if (y > 0) {
                tempbitmap = Bitmap.createScaledBitmap(tempbitmap, x, y, true);
            }
        }
        tempbitmap = Bitmap.createBitmap(tempbitmap, 0, 0, tempbitmap.getWidth(), tempbitmap.getHeight(), matrix, true);
        buffer.add(tempbitmap);
        return buffer.size()-1;
    }

    /**
     * Returns {@link Bitmap} from the buffer
     * @param i The specific bitmap you want
     * @return a bitmap
     */
    public Bitmap get(int i) {
        if (i<buffer.size()) {
            return buffer.get(i);
        } else {
            return null;
        }
    }

    /**
     * @return True if there are no animations
     */
    @SuppressWarnings("unused")
    public boolean isEmpty() {
        return buffer.isEmpty();
    }

    /**
     * The size of the buffer.  Remember that this is the total number of elements, but the array
     * runs 0-size-1
     * @see ArrayList
     * @return Number of elements in the buffer
     */
    @SuppressWarnings("unused")
    public int size() {
        return buffer.size();
    }

    /**
     * Adds a {@link Bitmap} to the buffer
     * @param bitmap Bitmap to be added
     * @return Index into the buffer
     */
    @SuppressWarnings("unused")
    public int AddBitmap(Bitmap bitmap) {
        buffer.add(bitmap);

        return buffer.size()-1;
    }

    /**
     * Adds {@link Bitmap} to buffer and scales it
     * @param bitmap Bitmap to be added
     * @param x width to scale
     * @param y height to scale
     * @return Index into the buffer
     */
    @SuppressWarnings("unused")
    public int AddandScaleBitmap(Bitmap bitmap, int x, int y) {
        Bitmap tempbitmap;
        tempbitmap=bitmap;
        if (x>0) {
            if (y > 0) {
                tempbitmap = Bitmap.createScaledBitmap(bitmap, x, y, true);
            }
        }
        buffer.add(tempbitmap);
        return buffer.size()-1;
    }

    /**
     * Adds {@link Bitmap} to buffer and flips direction.  
     * @param bitmap The bitmap to be added
     * @return Index into the buffer
     */
    @SuppressWarnings("unused")
    public int AddFlippedBitmap(Bitmap bitmap) {
        Bitmap tempbitmap;
        Matrix matrix;
        matrix=new Matrix();
        matrix.setScale(-1,1);
        tempbitmap=Bitmap.createBitmap(bitmap, 0,0,bitmap.getWidth(),bitmap.getHeight(),matrix,true);
        buffer.add(tempbitmap);
        return buffer.size()-1;
    }

    /**
     * Adds {@link Bitmap} to buffer, scales it, and flips direction
     * @param bitmap Bitmap to add to buffer
     * @param x Width to scale
     * @param y Height to scale
     * @return Index into buffer
     */
    @SuppressWarnings("unused")
    public int AddandScaleFlippedBitmap(Bitmap bitmap, int x, int y) {
        Bitmap tempbitmap;
        Matrix matrix;
        matrix=new Matrix();
        matrix.setScale(-1,1);
        tempbitmap = Bitmap.createScaledBitmap(bitmap, x, y, true);
        tempbitmap=Bitmap.createBitmap(tempbitmap, 0, 0, tempbitmap.getWidth(), tempbitmap.getHeight(), matrix, true);
        buffer.add(tempbitmap);
        return buffer.size()-1;
    }

    /**
     * Converts the current buffer into a scaled buffer... Useful to load bitmaps at their native
     * resolutions, and then scale them to the resolution you'll be using them in.  Ideally, pre
     * scaled bitmaps are faster than bitmaps that need to be scaled in the draw() phase.  
     * Note that this does nothing to this buffer, but instead returns a new copy of the buffer with the 
     * scaling applied.  (i.e. this is a non-destructive method
     * @param x desired width
     * @param y desired height
     * @return A scaled copy of the buffer
     */
    @SuppressWarnings("unused")
    public BitmapBuffer scaleBuffer(int x, int y) {
        BitmapBuffer temp = new BitmapBuffer();
        for (int i=0;i<buffer.size();i++) {
            temp.AddandScaleBitmap(buffer.get(i),x,y);
        }
        return temp;
    }
    /**
     * Converts the current buffer into a scaled buffer... Useful to load bitmaps at their native
     * resolutions, and then scale them to the resolution you'll be using them in.  Ideally, pre
     * scaled bitmaps are faster than bitmaps that need to be scaled in the draw() phase.
     * Note that this does nothing to this buffer, but instead returns a new copy of the buffer with the 
     * scaling applied.  (i.e. this is a non-destructive method
     * @param x desired width
     * @param y desired height
     * @return A scaled copy of the buffer
     */
    @SuppressWarnings("unused")
    public BitmapBuffer scaleBuffer(float x, float y) {
        BitmapBuffer temp = new BitmapBuffer();
        for (int i=0;i<buffer.size();i++) {
            temp.AddandScaleBitmap(buffer.get(i),(int)x,(int)y);
        }
        return temp;
    }

    /**
     * flips all images in the buffer left to right.  Useful to load an image in one direction,
     * and flip them at run time.
     * Note that this does not change this buffer, but instead returns a new copy with the modifications
     * changed.  In other words, this is a non-destructive method.
     * @return a BitmapBuffer with the images flipped left to right
     */
    @SuppressWarnings("unused")
    public BitmapBuffer flipLeftBuffer() {
        Matrix matrix;
        matrix=new Matrix();
        matrix.setScale(-1,1);
        BitmapBuffer temp = new BitmapBuffer();
        for (int i=0;i<buffer.size();i++) {
            temp.AddFlippedBitmap(buffer.get(i));
        }
        return temp;
    }

    /**
     * Draw frame on the {@link Canvas} at location dest
     * @param canvas Canvas provided by your Surface
     * @param frame Index into buffer
     * @param dest {@link RectF} location
     * @param paint {@link Paint} object
     */
    @SuppressWarnings("unused")
    public void draw(Canvas canvas, int frame, RectF dest,Paint paint) {
        canvas.drawBitmap(buffer.get(frame),null,dest,paint);
    }

    /**
     * Adds frames from selected {@link Spritesheet}
     * @param spritesheet Initialized spritesheet
     * @return number of frames
     */
    @SuppressWarnings("unused")
    public int createFromSpriteSheet(Spritesheet spritesheet) {
        for (int i=0;i<spritesheet.size();i++) {
            buffer.add(spritesheet.getFrame(i));
        }
        return buffer.size();
    }
    /**
     * Adds one buffer to another
     * @param newbuffer Buffer to add
     * @return The new size of the buffer
     */
    @SuppressWarnings("unused")
    public int addBuffer(BitmapBuffer newbuffer) {
        for (int i=0;i<newbuffer.size();i++) {
            buffer.add(newbuffer.get(i));
        }
        return buffer.size();
    }
}