//    RetroPixel (2016)


import java.awt.*;
import java.awt.image.*;
import java.io.*;
import java.util.*;
import javax.imageio.*;

public class RetroPixel {

    //  Variables
    
    public static final int MODE__C64_HIRES = 1; // "High" resolution, very limited colors
    public static final int MODE__C64_MULTICOLOR = 2; // Lower resolution but better colors
    public static final int MODE__PC_CGA_M4_P1 = 3;
    public static final int MODE__PC_EGA_16C = 4; // EGA with 16 colors palette
    public static final int MODE__PC_EGA_64CP = 5; // EGA with 64 colors palette and 16 of them used
    public static final int MODE__AMIGA_PAL = 6;
    public static final int MODE__AMIGA_NTSC = 7;
    public static final int MODE__AMIGA = 8; // Either PAL or NTSC, whatever is better for input image aspect ratio

    private int mode;
    private int pixelsize;
    
    private int width;
    private int height;
    private int[] fullpalette;
    private int pixelwidth;
    private int pixelheight;
    
    //  Constructors
    
    /**
     * Create new instance in specific mode.
     * @mode  One of the modes listed in this class
     */
    public RetroPixel(int mode) {
        this(mode,1);
    }

    /**
     * Create new instance in specific mode and with multiplied pixel size.
     * @mode   One of the modes listed in this class
     * @param  pixelsize  Increase to make final image bigger without changing generated image resolution (default 1, values like 1-4 makes most sense depending on mode and your own screen resolution)
     */
    public RetroPixel(int mode, int pixelsize) {
        this.mode=mode;
        this.pixelsize=pixelsize;
    }

    //  Accessors
    
    /**
     * Read image file, do retropixeling, save new image to file.
     */
    public void generateFile(File inputfile, File outputfile) throws Exception {
        // Read image
        BufferedImage image=ImageIO.read(inputfile);
        // Create actual image
        BufferedImage retroimage=generateImage(image);
        // Save file, image type is read from 'outputfile' name suffix (png,jpg...)
        String outputfilename=outputfile.getName().toLowerCase();
        int ind=outputfilename.indexOf('.');
        String imagetype=outputfilename.substring(ind+1);
        ImageIO.write(retroimage,imagetype,outputfile);
    }
    
    /**
     * Turn image to retropixel image.
     */
    public BufferedImage generateImage(BufferedImage sourceimage) {
        
        // Get image size
        int sourcewidth=sourceimage.getWidth();
        int sourceheight=sourceimage.getHeight();
        double sourceaspectratio=1.0*sourcewidth/sourceheight;
        setParams(sourceaspectratio);
        double retroaspectratio=1.0*(width*pixelwidth)/(height*pixelheight);
        
        // Create correct size image
        BufferedImage scaled=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d=scaled.createGraphics();
        g2d.addRenderingHints(new RenderingHints(RenderingHints.KEY_RENDERING,RenderingHints.VALUE_RENDER_QUALITY));
        
        // Scale
        double ratioratio=retroaspectratio/sourceaspectratio;
        if (ratioratio>=0.9 && ratioratio<1.1) {
            // Allow small ~10% change in aspect ratio
            g2d.drawImage(sourceimage,0,0,width,height,null);
        } else {
            // Leave black borders
            if (sourceaspectratio>retroaspectratio) {
                // Original is wider, leave empty at top/bottom
                double d=1.0*sourcewidth/(width*pixelwidth);
                int useheight=(int)((sourceheight/d)/pixelheight+0.5);
                int empty=(height-useheight)/2;
                g2d.drawImage(sourceimage,0,empty,width,height-empty,0,0,sourcewidth,sourceheight,null);
            } else {
                // Original is narrower, leave empty at left/right
                double d=1.0*sourceheight/(height*pixelheight);
                int usewidth=(int)((sourcewidth/d)/pixelwidth+0.5);
                int empty=(width-usewidth)/2;
                g2d.drawImage(sourceimage,empty,0,width-empty,height,0,0,sourcewidth,sourceheight,null);
            }
        }
        
        // Change pixel colors using full palette
        int[] paletteinuse=fullpalette;
        int[][] imageusingpalettecolors=new int[height][width];
        for (int y=0; y<height; y++) {
            for (int x=0; x<width; x++) {
                imageusingpalettecolors[y][x]=getPaletteColor(scaled.getRGB(x,y),paletteinuse);
            }
        }
        
        // Hardware limits
        if (mode==MODE__C64_HIRES) {
            // Use 2 colors on each 8*8 pixel area
            for (int y=0; y<height; y+=8) {
                for (int x=0; x<width; x+=8) {
                    limitColors(imageusingpalettecolors,x,y,8,8,2);
                }
            }
        } else if (mode==MODE__C64_MULTICOLOR) {
            // Use 4 color on each 4*8 pixels area
            for (int y=0; y<height; y+=8) {
                for (int x=0; x<width; x+=4) {
                    limitColors(imageusingpalettecolors,x,y,4,8,4);
                }
            }
        } else if (mode==MODE__PC_EGA_64CP) {
            // Change to use 16 colors from full palette
            limitColors(imageusingpalettecolors,0,0,width,height,16);
        } else if (mode==MODE__AMIGA || mode==MODE__AMIGA_PAL || mode==MODE__AMIGA_NTSC) {
            // Change to use 32+32 color palette
            paletteinuse=getAmigaEHBPalette(imageusingpalettecolors);
            for (int y=0; y<height; y++) {
                for (int x=0; x<width; x++) {
                    imageusingpalettecolors[y][x]=getPaletteColor(scaled.getRGB(x,y),paletteinuse);
                }
            }
        }

        // Draw final image, changing pixel sizes and using actual colors
        int mx=pixelsize*pixelwidth;
        int my=pixelsize*pixelheight;
        BufferedImage retroimage=new BufferedImage(width*mx,height*my,BufferedImage.TYPE_INT_RGB);
        //
        for (int y=0; y<height; y++) {
            for (int x=0; x<width; x++) {
                int color=paletteinuse[imageusingpalettecolors[y][x]];
                for (int py=0; py<my; py++) {
                    for (int px=0; px<mx; px++) {
                        retroimage.setRGB(x*mx+px,y*my+py,color);
                    }
                }
            }
        }
        
        // Ready
        return retroimage;
        
    }

    private void setParams(double origaspectratio) {
        // Commodore 64
        if (mode==MODE__C64_HIRES || mode==MODE__C64_MULTICOLOR) {
            width=(mode==MODE__C64_HIRES?320:160);
            height=200;
            fullpalette=new int[]{c(0,0,0),c(255,255,255),c(136,0,0),c(170,255,238),c(204,68,204),c(0,204,85),c(0,0,170),c(238,238,119),
                                  c(221,136,85),c(102,68,0),c(255,119,119),c(51,51,51),c(119,119,119),c(170,255,102),c(0,136,255),c(187,187,187)};
            pixelwidth=(mode==MODE__C64_HIRES?1:2);
            pixelheight=1;
        }
        // CGA, Mode 4, Palette #1, high intensity
        if (mode==MODE__PC_CGA_M4_P1) {
            width=320;
            height=200;
            fullpalette=new int[]{c(0,0,0),c(85,255,255),c(255,85,255),c(255,255,255)};
            pixelwidth=1;
            pixelheight=1;
        }
        // EGA
        if (mode==MODE__PC_EGA_16C || mode==MODE__PC_EGA_64CP) {
            width=640;
            height=480; // Original standard was 350, but that would require 1:1.37 pixel ratio
            if (mode==MODE__PC_EGA_16C) {
                fullpalette=new int[]{c(0,0,0),c(0,0,170),c(0,170,0),c(0,170,170),c(170,0,0),c(170,0,170),c(170,95,0),c(170,170,170),
                                      c(95,95,95),c(95,95,255),c(95,255,95),c(95,255,255),c(255,95,95),c(255,95,255),c(255,255,95),c(255,255,255)};
            } else {
                fullpalette=new int[64];
                for (int r=0; r<4; r++) {
                    for (int g=0; g<4; g++) {
                        for (int b=0; b<4; b++) {
                            fullpalette[r*4*4+g*4+b]=c(r*85,g*85,b*85);
                        }
                    }
                }
            }
            pixelwidth=1;
            pixelheight=1;
        }
        // Amiga
        if (mode==MODE__AMIGA || mode==MODE__AMIGA_PAL || mode==MODE__AMIGA_NTSC) {
            width=320;
            if (mode==MODE__AMIGA_PAL) {
                height=512;
            } else if (mode==MODE__AMIGA_NTSC) {
                height=400;
            } else {
                double halfaspectratio=320.0/((256.0+200.0)/2.0);
                if (origaspectratio<=halfaspectratio) {
                    height=512;
                } else {
                    height=400;
                }
            }
            fullpalette=new int[4096];
            for (int r=0; r<16; r++) {
                for (int g=0; g<16; g++) {
                    for (int b=0; b<16; b++) {
                        fullpalette[r*16*16+g*16+b]=c(r*17,g*17,b*17);
                    }
                }
            }
            pixelwidth=2;
            pixelheight=1;
        }
    }

    private static int c(int r, int g, int b) {
        return (r*256*256+g*256+b);
    }
    
    private void limitColors(int[][] imageusingpalettecolors, int x, int y, int w, int h, int colorcount) {
        // Get color counts
        PaletteColorUsage[] counts=getSortedPaletteColorUsage(imageusingpalettecolors,x,y,w,h);
        // Create limited palette
        int[] limitedpalette=new int[colorcount];
        for (int n=0; n<colorcount; n++) {
            limitedpalette[n]=fullpalette[counts[n].getPaletteIndex()];
        }
        // Rechoose colors using limited palette
        reChooseColorsUsingLimitedPalette(imageusingpalettecolors,x,y,w,h,counts,limitedpalette);
    }

    private PaletteColorUsage[] getSortedPaletteColorUsage(int[][] imageusingpalettecolors, int x, int y, int w, int h) {
        // Go through area and count used colors
        PaletteColorUsage[] counts=new PaletteColorUsage[fullpalette.length];
        for (int n=0; n<fullpalette.length; n++) {
            counts[n]=new PaletteColorUsage(n);
        }
        for (int ay=y; ay<y+h; ay++) {
            for (int ax=x; ax<x+w; ax++) {
                counts[imageusingpalettecolors[ay][ax]].addCount();
            }
        }
        // Sort
        Arrays.sort(counts);
        // Return
        return counts;
    }

    private void reChooseColorsUsingLimitedPalette(int[][] imageusingpalettecolors, int x, int y, int w, int h, PaletteColorUsage[] counts, int[] limitedpalette) {
        // Rechoose colors using limited palette
        for (int ay=y; ay<y+h; ay++) {
            for (int ax=x; ax<x+w; ax++) {
                int limitedpalettecolortouse=getPaletteColor(fullpalette[imageusingpalettecolors[ay][ax]],limitedpalette);
                imageusingpalettecolors[ay][ax]=counts[limitedpalettecolortouse].getPaletteIndex();
            }
        }
    }

    // (Not so very happy how colors are chosen here, should choose more brighter and different from each other colors)
    private int[] getAmigaEHBPalette(int[][] imageusingpalettecolors) {
        // Get color counts
        PaletteColorUsage[] counts=getSortedPaletteColorUsage(imageusingpalettecolors,0,0,width,height);
        // Create limited palette
        int[] ehbpalette=new int[64];
        // Set some default colors, otherwise chosen colors tend to be too average and flat
        ehbpalette[0]=c(17,17,17);
        ehbpalette[1]=c(255,0,0);
        ehbpalette[2]=c(0,255,0);
        ehbpalette[3]=c(0,0,255);
        ehbpalette[4]=c(255,255,0);
        ehbpalette[5]=c(255,0,255);
        ehbpalette[6]=c(0,255,255);
        ehbpalette[7]=c(255,255,255);
        ehbpalette[8]=c(238,204,170);
        // Rest of colors by usage, only bright colors
        int countindex=0;
        for (int n=9; n<32; n++) {
            ehbpalette[n]=fullpalette[counts[countindex].getPaletteIndex()];
            countindex++;
            if (!isColorNeeded(ehbpalette,n)) {
                n--;
            }
        }
        // EHB colors
        for (int n=32; n<64; n++) {
            ehbpalette[n]=ehb(ehbpalette[n-32]);
        }
        // Return new palette
        return ehbpalette;
    }

    private boolean isColorNeeded(int[] limitedpalette, int index) {
        for (int n=0; n<index; n++) {
            if (limitedpalette[index]==limitedpalette[n]) {
                return false; // Already exists
            }
        }
        int r=(limitedpalette[index]&0xFF0000)>>16;
        int g=(limitedpalette[index]&0x00FF00)>>8;
        int b=(limitedpalette[index]&0x0000FF);
        if (r<96 && g<96 && b<96) {
            return false; // Dark color, assuming EHB colors will have something near this
        }
        return true;
    }

    private int ehb(int rgb) {
        int r=(rgb&0xFF0000)>>16;
        int g=(rgb&0x00FF00)>>8;
        int b=(rgb&0x0000FF);
        r/=17;
        g/=17;
        b/=17;
        r/=2;
        g/=2;
        b/=2;
        r*=17;
        g*=17;
        b*=17;
        return c(r,g,b);
    }
    
    private int getPaletteColor(int imagepixelrgb, int[] palette) {
        int paletteindex;
        if (Math.random()<0.6) {
            paletteindex=getPaletteColorIndex(imagepixelrgb,palette,true,(mode!=MODE__C64_HIRES));
        } else {
            paletteindex=getPaletteColorIndex(imagepixelrgb,palette,false,false);
        }
        return paletteindex;
    }
    
    private int getPaletteColorIndex(int rgb, int[] palette, boolean rgb_hsb, boolean dither) {
        int r=(rgb&0xFF0000)>>16;
        int g=(rgb&0x00FF00)>>8;
        int b=(rgb&0x0000FF);
        int bestcolorindex=-1;
        double bestcolordiff=1.0;
        int secondbestcolorindex=-1;
        double secondbestcolordiff=1.0;
        for (int n=0; n<palette.length; n++) {
            double diff=(rgb_hsb?getColorDiffByRGB(palette[n],r,g,b):getColorDiffByHSB(palette[n],r,g,b));
            if (bestcolorindex==-1) {
                bestcolorindex=n;
                bestcolordiff=diff;
            } else if (diff<bestcolordiff) {
                secondbestcolorindex=bestcolorindex;
                secondbestcolordiff=bestcolordiff;
                bestcolorindex=n;
                bestcolordiff=diff;
            } else if (secondbestcolorindex==-1) {
                secondbestcolorindex=n;
                secondbestcolordiff=diff;
            } else if (diff<secondbestcolordiff) {
                secondbestcolorindex=n;
                secondbestcolordiff=diff;
            }
        }
        int colortouse;
        if (!dither || bestcolordiff<0.01 || secondbestcolordiff>0.2) {
            colortouse=bestcolorindex;
        } else {
            double bi=1.0/bestcolordiff;
            double sbi=1.0/secondbestcolordiff;
            double ti=bi+sbi;
            double rnd=Math.random()*ti;
            if (rnd<bi) {
                colortouse=bestcolorindex;
            } else {
                colortouse=secondbestcolorindex;
            }
        }
        return colortouse;
    }

    private double getColorDiffByRGB(int palettecolor, int r, int g, int b) {
      
        int pr=(palettecolor&0xFF0000)>>16;
        int pg=(palettecolor&0x00FF00)>>8;
        int pb=(palettecolor&0x0000FF);
        int rd=Math.abs(pr-r);
        int gd=Math.abs(pg-g);
        int bd=Math.abs(pb-b);

        return ((rd+gd+bd)/(3.0*255.0)); // 0..1

    }

    private double getColorDiffByHSB(int palettecolor, int r, int g, int b) {
        
        int pr=(palettecolor&0xFF0000)>>16;
        int pg=(palettecolor&0x00FF00)>>8;
        int pb=(palettecolor&0x0000FF);
        float[] phsb=Color.RGBtoHSB(pr,pg,pb,null);

        float[] hsb=Color.RGBtoHSB(r,g,b,null);

        double hd=Math.abs(phsb[0]-hsb[0]);
        hd=Math.min(hd,1.0-hd)*2.0;
        double sd=Math.abs(phsb[1]-hsb[1]);
        double bd=Math.abs(phsb[2]-hsb[2]);

        if (phsb[2]==0.0 || hsb[2]==0.0) {
            return bd;
        }

        if (phsb[1]==0.0 || hsb[1]==0.0) {
            return (bd+sd)/2.0;
        }

        return (bd+sd+hd)/3.0;

    }
    
    private class PaletteColorUsage implements Comparable<PaletteColorUsage> {

        private int paletteindex;
        private int count;
        
        protected PaletteColorUsage(int paletteindex) {
            this.paletteindex=paletteindex;
            count=0;
        }

        protected int getPaletteIndex() {
            return paletteindex;
        }

        protected void addCount() {
            count++;
        }

        protected int getCount() {
            return count;
        }

        public int compareTo(PaletteColorUsage another) {
            int anothercount=another.getCount();
            if (count>anothercount) {
                return -1;
            } else if (count<anothercount) {
                return 1;
            }
            return 0;
        }
        
    }

}