package thesis;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.FileReader;
import java.math.BigInteger;
import java.util.Random;
import javax.imageio.ImageIO;
import java.io.IOException;
import java.util.Date;
import java.io.File;
import java.util.ArrayList;

public class Thesis {
public static Random r = new Random();
public static String Random_key = "";    
public static  String  AMBIG_BIT ="";
public static String DNA_Image = "";
public static int Image_length = 0;
public static int DNASegment =r.nextInt(5  + 0) + 0;
public static int WhenStart  =r.nextInt(30000  + 0) + 0;
public static int [] Archies =new int[900000];
public static int PaddingSize = 0;
//////////////////
/////////////////

    // Convert Image to binary String
    public static void Binary_Image( String Image)throws Exception{ 
         // 2 second
         String Binary_Image = "";
          BufferedImage bImage = ImageIO.read(new File(Image));
          ByteArrayOutputStream bos = new ByteArrayOutputStream();
          ImageIO.write(bImage, "jpg", bos );
          byte [] byte_Image = bos.toByteArray();
                  for (int i =0; i< byte_Image.length; i++){
                  Binary_Image += String.format("%8s", Integer.toBinaryString(byte_Image[i] & 0xFF)).replace(' ', '0');
                  }   
                 // System.out.println("The binary image is: "+Binary_Image);
                //  System.out.println("The binary image is: "+Binary_Image.length());    
               Feistel_Network (Binary_Image );   
            //   decoder_binary_Image (Binary_Image);
    }

    //Split String Image to blocks
     private static  ArrayList<String>  splitStringBySize(String str, int size) {
    ArrayList<String> split = new ArrayList<>();
    for (int i = 0; i <= str.length() / size; i++) {
        split.add(str.substring(i * size, Math.min((i + 1) * size, str.length())));
    }
    return split;
}
   
    //Encryption process
    public static void Feistel_Network (String Binary_Image )throws Exception{ 
       
      
     String Righttext ="" , Lefttext="" ; 
     String AnewRight = ""; 
     StringBuffer AnewLeft=new StringBuffer();
     String After_Encrypt = "";

        //for add padding in the last block
         for(int j =0 ; Binary_Image.length() % 64 !=0 ; j++ ){
            Binary_Image+="0";
            PaddingSize += 1;
 
         }

          System.out.println("before Feistel_Network process : "+ Binary_Image);
           
         
            ArrayList<String> split=splitStringBySize(Binary_Image, 64);
           // System.out.println(split.size());

  
        for(int i=0;i< Binary_Image.length()/64;i++){            
              Lefttext= split.get(i).substring(0,32);
              Righttext=  split.get(i).substring(32,64); 
              AnewLeft.delete(0,  Binary_Image.length()/64);

              for(int j=0;j<32;j++){
                   // AND function between key and RightText
                  if ((Righttext.charAt(j) & Random_key.charAt(j)) == '1')
                      AnewRight +=  "1";
                      else 
                      AnewRight +=  "0";   
                  // XOR the output of previus step with LeftText
                  AnewLeft.append(AnewRight.charAt(j)^Lefttext.charAt(j));
              }       
       After_Encrypt += Righttext + AnewLeft ;  
       }

    //  System.out.println(PaddingSize);   
        
        System.out.println("binary Image : "+ After_Encrypt);    
      DNA_Image= Convert_Binary_To_DNA_Base(After_Encrypt);
      Image_length = DNA_Image.length();
  
      
     System.out.println("Extract Image   :"+DNA_Image); 
     DNAFile();
     } 


    // Convert binary String to DNA sequence
    public static String Convert_Binary_To_DNA_Base( String Binary_Data )throws Exception { 
     String ConTo_DNA = "";
      for (int i = 0 ; i <= Binary_Data.length()-1; i++){
           String div_string = Binary_Data.substring(i, i+2);
              if(div_string.equals("00"))
                  ConTo_DNA += "A"; 
              if(div_string.equals("10"))
                  ConTo_DNA += "G";
              if(div_string.equals("01"))
                  ConTo_DNA +=  "C";
              if(div_string.equals("11"))
                  ConTo_DNA += "T";
              i++;

              }
     return ConTo_DNA;
    } 
    
    // Read DNA file
    public static void DNAFile () throws IOException, Exception {
         // 0 second
         StringBuilder DNA_File = new StringBuilder();
         char[] buffer = new char[10];  
         try (BufferedReader reader = new BufferedReader(new FileReader("C:\\base64\\AC153526.txt"))) {
         while (reader.read(buffer) != -1) {
            DNA_File.append(new String(buffer)); 
        }}
         
         
         
         // System.out.println("The orginal DNA sequence is: "+ DNA_File.toString());    
          HidingProcess(DNA_File);
        
    }

    // Hiding process
   public static void HidingProcess (StringBuilder DNA_File) throws IOException, Exception {     

            for(int i = WhenStart , j = 0; j <Image_length ; i++ ,j++){

                     // will hide the image letter after 1 DNA base
                      DNA_File.insert(i, DNA_Image.charAt(j)); // Add
                     
                  //    if ( j == LastString.length())  }           
                  i = i+DNASegment -1;
                //DNA_File.setCharAt(i, DNA_Image.charAt(j)); //تبديل
              
           }
           System.out.println("compare   :"+DNA_File); 
            
 
            
        // for generate the AMBIG_BITs
        int randomInt = 0;
        char randomChar ;
        int RandomAdd;
        String setOfCharacters = "ATGC";
        for(int i = 0; i < DNA_Image.length()/10; i++)  {            
        randomInt = r.nextInt(setOfCharacters.length());
        randomChar = setOfCharacters.charAt(randomInt); 
        AMBIG_BIT += randomChar;
        }
        //System.out.println("AMBIG_BIT   :"+AMBIG_BIT);    

         Archies =new int[AMBIG_BIT.length()];
         for(int i = 0  ,j=0; i < AMBIG_BIT.length(); i++ , j++ )  {
         RandomAdd =r.nextInt(50  + 0) + 0;
          Archies[i] = j +RandomAdd ;
         DNA_File.insert(j +=RandomAdd,AMBIG_BIT.charAt(i) ); // Add          
         //  buffer.setCharAt(j +=RandomAdd,Noise.charAt(i)); //swap
         }

        //System.out.println("togather     :"+  Archies.length);
        //System.out.println("DNA_File length is:" +DNA_File.length());
         
         
        
        
          //System.out.println("The DNASegment        is: "+ DNASegment); 
          // System.out.println("The MesSegment        is: "+ MesSegment); 
          //System.out.println("The WhenStart         is: "+ WhenStart); 
          // System.out.println("The fake DNA sequence is: "+ DNA_File);  
           Extract_Image_from_DNA( DNA_File ); 
        }

 
/////////////////////////////////  
//////////////////////////////////// Decode process
////////////////////////////////
   
     // Extraction Image form DNA Sequence  
     public static void Extract_Image_from_DNA (StringBuilder DNASequence) throws IOException, Exception {       
           
         //Extract the AMBIG_BITs
          for(int i = Archies.length-1 ; i >=0; i-- ){
             DNASequence.deleteCharAt(Archies[i]);               
             }        
           System.out.println("compare   :"+DNASequence);
         ///
         
         
         
         // Extract Image
         String ExtractImage = "";
           for(int i=WhenStart ,j=0; j< Image_length;i++ ,j++){
                  ExtractImage += DNASequence.charAt(i);  
                  
                    i = i+DNASegment -1;
           }
         
           
           
           System.out.println("Extract Image   :"+ExtractImage); 
          Convert_DNA_Base_To_Binary(ExtractImage);
        }

     
     
    // Convert DNA Sequence to Binary Sequence      
    public static void Convert_DNA_Base_To_Binary( String DNA_Image )throws Exception {  
            String Binary_Image = new String();
            for (int i = 0 ; i <= DNA_Image.length()-1; i++){
                  if(DNA_Image.charAt(i)==('A'))
                      Binary_Image += "00"; 
                  if(DNA_Image.charAt(i)==('G'))
                      Binary_Image += "10";
                  if(DNA_Image.charAt(i)==('C')) 
                      Binary_Image +=  "01";
                  if(DNA_Image.charAt(i)==('T') )
                      Binary_Image += "11";
              }     
             System.out.println("binary Image : "+ Binary_Image);   
             Reverse_Feistel_Network ( Binary_Image );                                             
        }   


    // Reverse feistel network process
    public static void Reverse_Feistel_Network (String Binary_Image )throws Exception{ 
        String Righttext , Lefttext ;
        String And_Result = ""; 
        StringBuffer AnewRight =new StringBuffer();
        String AnewLeft = ""; 
         String strNew  = "";
/////////////////////////////////////

        
              ArrayList<String> split=splitStringBySize(Binary_Image, 64);
             // System.out.println(split.size());

        for(int f=0;f<Binary_Image.length()/64;f++){            
              Righttext = split.get(f).substring(0,32);
              Lefttext=  split.get(f).substring(32,64); 
              AnewRight.delete(0, Binary_Image.length()/64);

              for(int i=0;i<32;i++){
                 // AND function between key nand RightText
              if ((Righttext.charAt(i) & Random_key.charAt(i)) == '1')
               AnewLeft +=  "1";
              else 
               AnewLeft +=  "0";   

              // XOR the output of previus step with LeftText
              AnewRight.append(AnewLeft.charAt(i)^Lefttext.charAt(i));         
       }
       And_Result +=  AnewRight + Righttext ;  
       
        
          
       }
       System.out.println("After Reverse_Feistel_Network process : "+ And_Result);

       if (PaddingSize != 0)
               strNew = And_Result.substring(0, And_Result.length()-PaddingSize);
       // System.out.println(" delete PaddingSize: "+ strNew);
       
       
       decoder_binary_Image(strNew);
     
     
    }


    // Convert Binary Sequence to image
    public static void decoder_binary_Image(String BinaryStringImage ) throws Exception  {   
                byte[] bval = new BigInteger(BinaryStringImage, 2).toByteArray();          
                InputStream in = new ByteArrayInputStream(bval, 1, bval.length);                 
                BufferedImage bImageFromConvert = ImageIO.read(in);
                ImageIO.write(bImageFromConvert, "jpg", new File("C:\\base64\\new.jpg"));              		
    }


//////////////////////////////   
//////////////////////////////////// Main
//////////////////////////////
    
    
    
 public static void main(String args[]) throws Exception{
             
    String imagePath = "C:\\base64\\1.jpg";
    //  System.out.println("=================Encoder Image to binary!=================");
       
    long startTime = new Date().getTime(); 
    Random_key += String.format("%32s", Integer.toBinaryString(r.nextInt()& 127 & 0xFF)).replace(' ', '0');
    //System.out.println("The random key is:"+ Random_key);
    
    
    Binary_Image (imagePath);

    
    
    long endTime = new Date().getTime();
    long timeElapsed = endTime - startTime;
    System.out.println("Execution time in milliseconds: " + timeElapsed);
   }
 
 
 
 
   // number between 0 or 1
    static int findRandom(){    
    // Generate the random number
    int num = (1 + (int)(Math.random() * 100)) % 2;
    return num;
}

    // Function to generate a random binary string of length N
    static String generateBinaryString(int N) throws Exception{
    String S = "";
    // Iterate over the range [0, N - 1]
    for(int i = 0; i < N; i++)  {     
        // Store the random number
        int x = findRandom();
        // Append it to the string
        S = S + String.valueOf(x);
    }
   
   // System.out.println("The Noise is       : "+S);    
    return S;
    // System.out.println(S);
}


    
    
}