import java.util.Objects;
import java.lang.Exception;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

import java.net.URL;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        boolean help_enqueued = false;
        boolean allow_networking = true;
        String matrix_file_name = "";

        int p = 0;
        while (p < args.length) {
            try {
                if (Objects.equals(args[p], "-h")) {    
                    help_enqueued = true;
                    p += 1;
                }
                else if (Objects.equals(args[p], "--offline")) {
                    allow_networking = false;
                    p += 2;
                }
                else {
                    matrix_file_name = args[p++];
                }
            }
            catch (Exception e) {
                System.err.println("[ERROR] Exception while parsing CLI arguments: " + e);
                System.err.println("[ERROR] Aborting further execution.");
                System.exit(1);
            }
        }

        if (help_enqueued) {
            printHelp(allow_networking);
            System.exit(0);
        }

        if (Objects.equals("", matrix_file_name)) {
            System.err.println("[WARN] No filename specified to read from, using default one");
            matrix_file_name = "random_matrix.txt";
        }

        File matrix_file = new File(matrix_file_name);
        if (!matrix_file.exists()) {
            if (allow_networking) {
                System.err.println("[WARN] File is missing, downloading random matrix from the server");
                fetchResource("http://lab2.kpi.dev:16554/matrix.py", matrix_file_name);
            } else {
                System.err.println("[WARN] File is missing; networking is disabled, not recovering");
                System.exit(1);
            }
        }

        // loading matrix data from file
        int[][] raw_m = loadMatrixFromFile(matrix_file);

        // creating original matrix object
        System.out.println("Original matrix:");
        Matrix m = new Matrix();
        m.init(raw_m);
        
        // transposing
        m.transpose();
        System.out.println("\nTransposed matrix:");
        m.print();

        // avg
        System.out.println("\nAverage value is " + m.getAvg());
    }

    private static void fetchResource(String remote_url, String output_filename) {
        try {
            BufferedInputStream in = new BufferedInputStream(new URL(remote_url).openStream());
            FileOutputStream fileOutputStream = new FileOutputStream(output_filename);

            byte dataBuffer[] = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
                fileOutputStream.write(dataBuffer, 0, bytesRead);
            }
        } catch (Exception e) {
            System.out.println("[ERROR] Failed to fetch resource " + output_filename + "from " + remote_url + " due to the following exception: " + e);
        }
    }

    private static void printHelp(boolean allow_net) {
        try {
            File help_file = new File("src/help.txt");

            if (!help_file.exists()) {
                System.err.println("[WARN] Help file is missing.");
                if (allow_net) {
                    System.err.println("[INFO] Trying to recover it from the git server");
                    fetchResource("http://lab2.kpi.dev:3000/dymik739/oop-labs-collection/raw/branch/lab2-dev/labs/2/src/help.txt", "src/help.txt");
                } else {
                    System.err.println("[INFO] Networking is disabled, not recovering");
                    System.exit(1);
                }
            }
    
            Scanner help_file_scanner = new Scanner(help_file);

            while (help_file_scanner.hasNextLine()) {
                System.out.println(help_file_scanner.nextLine());
            }
    
            help_file_scanner.close(); 
        } catch (Exception e) {
            System.out.println("[ERROR] Failed to read help due to the following exception: " + e);
            System.exit(1);
        }
    }

    private static int[][] loadMatrixFromFile(File matrix_file) {
        try {
            Scanner matrix_file_reader = new Scanner(matrix_file);

            ArrayList<String> raw_matrix_lines = new ArrayList<String>();
            while (matrix_file_reader.hasNextLine()) {
                raw_matrix_lines.add(matrix_file_reader.nextLine());
            }
    
            ArrayList<String[]> baked_matrix_lines = new ArrayList<String[]>();
    
            for (String s : raw_matrix_lines) {
                baked_matrix_lines.add(s.split(" "));
            }
            
            int ref_length = baked_matrix_lines.get(0).length;
            int[][] baked_matrix = new int[baked_matrix_lines.size()][ref_length];
            
            for (int i = 0; i < baked_matrix_lines.size(); i++) {
                if (baked_matrix_lines.get(i).length != ref_length) {
                    System.err.println("[ERROR] Matrix lines have different length! Assuming the matrix was corrupted");
                    System.exit(2);
                }

                for (int j = 0; j < baked_matrix_lines.get(i).length; j++) {
                    baked_matrix[i][j] = Integer.parseInt(baked_matrix_lines.get(i)[j]);
                }
            }

            return baked_matrix;
        } catch (Exception e) {
            System.err.println("[ERROR] Failed to read matrix from file " + matrix_file.getName());
            System.exit(1);
            return new int[1][1];
        }
    }
}