import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.io.File;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.nio.file.Path;
import java.util.Arrays;
import java.nio.charset.Charset;

import sun.awt.CharsetString;
/**
 * Umsetzung des unter https://de.wikipedia.org/wiki/RC4 beschriebenen
 * RC4-Verfahrens mit einer Alphabetlänge von 256.
 */


public class RC4 {
    //Byte-Feld der Laenge 256
    private byte s[] = new byte[256];

    public static final Charset ASCII = Charset.forName("ASCII");


    /**
     * Konstruktor, der den zu verwendenden geheimen Schlüssel
     * entgegen nimmt. Die Zeichen sollten im Standard-ASCII-Format
     * vorliegen.
     * @param geheimerSchluessel Geheimer Schlüssel.
     * @throws UnsupportedEncodingException
     */
    public RC4(String geheimerSchluessel) throws UnsupportedEncodingException {
        //Byte-Feld, dass den geheimen Schluessel enthaelt
        byte[] key = geheimerSchluessel.getBytes(ASCII);


        //Byte-Feld, dass die Laenge des Schluessels enthaelt
        byte length = (byte) key.length;

        //Die Werte 0 bis 255 werden dem Feld s zugewiesen
        for(int i = 0; i<256;i++) {
            s[i] = (byte) i;
        }
        int j = 0;
        for(int i=0;i<256;i++) {
            j = (j+s[i]+key[i % length]) %256  & 0xFF;
            //s[i] und s[j] vertauschen
            byte temp;
            temp = s[i];
            s[i] = s[j];
            s[j] = temp;
        }
    }


    /**
     * Wende das RC4-Verfahren auf eine Zeichenkette an.
     * @param eingabe Zu transformierende Zeichenkette.
     * @return Transformierte Zeichenkette.
     * @throws UnsupportedEncodingException
     */
    public String berechneTransformation(String eingabe) {


        byte[] klarT;
        klarT = eingabe.getBytes(ASCII);
        byte[] schluesselT=new byte[klarT.length];
        int i = 0;
        int j = 0;

        for(int n = 0; n<klarT.length;n++) {
            i = (i + 1)%256;
            j = (j+s[i]) %256 &0xFF;
            //Vertausche s[i] und s[j]
            byte temp;
            temp=s[i];
            s[i]= s[j];
            s[j]=temp;

            //Berechnen der "Zufallszahl"
            int zufallszahl;
            zufallszahl= s[((s[i] + s[j])%256)&0xFF];
            //Verschluesseln des Textes an der Stelle n
            schluesselT[n]= (byte) ((zufallszahl ^ klarT[n]) &0xFF);
        }
        //  String plain = new String(klarT, "US-ASCII");
        String ausgabe;

        ausgabe = new String(schluesselT, ASCII);

        return ausgabe;


    }

    /**
     * Wende das RC4-Verfahren auf eine Datei an.
     * @param dateiLesen      Name der zu transformierenden Datei.
     * @param dateiSchreiben  Name der zu erstellenden Datei.
     * @throws IOException
     */
    public void transformiereDatei(String dateiLesen,
            String dateiSchreiben) throws IOException {
        File file = new File(dateiLesen);
        Path path =file.toPath();

        byte[] encoded = Files.readAllBytes(path);
        String encodedString = new String(Arrays.toString(encoded));
        String  output = new String(encodedString);
        path = FileSystems.getDefault().getPath(dateiSchreiben);
        try( BufferedWriter writer = Files.newBufferedWriter(path))
        {
            writer.write(this.berechneTransformation(output));
        }



    }
}