import java.util.*;
import java.io.*;
import java.lang.Math;

class MancalaNetwork extends MancalaPlayer implements Cloneable

{
    //constants
    private int NUM_BINS=3;
    private int MAX_STONES = 16;
    private int NUM_HIDDEN_NEURONS=10;
    private double LAMBDA=0.7;
    private double ALPHA=0.000001;
    
    //variables
    private Neuron[] inputNeurons;
    private Neuron[] hiddenNeurons;
    private Neuron outputNeuron;

    private Delta inputDelta;
    private Delta inputDeltaAcc;
    private Delta hiddenDelta;
    private Delta hiddenDeltaAcc;
    private Delta outputDelta;
    private Delta outputDeltaAcc;
    
    public int playerNum;
    public MancalaNetwork opp;

    //Constructor for new network
    public MancalaNetwork(int playerNum)
    {
        this.initNeurons();
        this.playerNum = playerNum;
    }
    
    private void initNeurons()
    {
        //Input layer
        this.inputNeurons = new Neuron[2*this.NUM_BINS];
        this.inputDelta = new Delta(2*this.NUM_BINS, this.MAX_STONES);
        this.inputDeltaAcc = new Delta(2*this.NUM_BINS, this.MAX_STONES);
        for (int i=0; i<2*this.NUM_BINS; ++i)
            this.inputNeurons[i] = new Neuron(this.MAX_STONES);
        
        //Hidden layer
        this.hiddenNeurons = new Neuron[this.NUM_HIDDEN_NEURONS];
        this.hiddenDelta = new Delta(this.NUM_HIDDEN_NEURONS, 2*this.NUM_BINS);
        this.hiddenDeltaAcc=new Delta(this.NUM_HIDDEN_NEURONS, 2*this.NUM_BINS);
        for (int i=0; i<this.NUM_HIDDEN_NEURONS; ++i)
            this.hiddenNeurons[i] = new Neuron(2*this.NUM_BINS);
        
        //Output layer
        this.outputNeuron = new Neuron(this.NUM_HIDDEN_NEURONS);
        this.outputDelta = new Delta(1, this.NUM_HIDDEN_NEURONS);
        this.outputDeltaAcc = new Delta(1, this.NUM_HIDDEN_NEURONS);
    }

    public void fromFile(String filename)
    {
        try
        {
            Scanner in = new Scanner(new File(filename));
            for (int i=0; i<this.inputNeurons.length; ++i)
                for (int j=0; j<(this.inputNeurons[0].weights).length; ++j)
                    this.inputNeurons[i].weights[j] = in.nextDouble();

            for (int i=0; i<this.hiddenNeurons.length; ++i)
                for (int j=0; j<(this.hiddenNeurons[0].weights).length; ++j)
                    this.hiddenNeurons[i].weights[j] = in.nextDouble();

            for (int j=0; j<(this.outputNeuron.weights).length; ++j)
                this.outputNeuron.weights[j] = in.nextDouble();

            if (in.hasNext())
                System.err.println("ERROR: Didn't read entire file");

            in.close();
        }
        catch (IOException e)
        {
            System.err.println("Error reading network from "+filename);
        }
    }

    public void toFile(String filename)
    {
        FileOutputStream out;
        PrintStream p;
        try
        {
            out = new FileOutputStream(filename);
            p = new PrintStream(out);
            double[] curr;
            for (int i=0; i<this.inputNeurons.length; ++i)
            {
                curr = this.inputNeurons[i].weights;
                for (int j=0; j<curr.length; ++j)
                    p.print(curr[j]+" ");
            }
            for (int i=0; i<this.hiddenNeurons.length; ++i)
            {
                curr = this.hiddenNeurons[i].weights;
                for (int j=0; j<curr.length; ++j)
                    p.print(curr[j]+" ");
            }
            for (int j=0; j<outputNeuron.weights.length; ++j)
                p.print(outputNeuron.weights[j]+" ");
            p.close();
        }
        catch (Exception e)
        {
            System.err.println("Error writing network to "+filename);
        }
    }
    
    public Object clone()
    {
        MancalaNetwork newNet = new MancalaNetwork(this.playerNum);
        for (int i=0; i<this.inputNeurons.length; ++i)
            for (int j=0; j<this.inputNeurons[0].weights.length; ++j)
                newNet.inputNeurons[i].weights[j]=inputNeurons[i].weights[j];

        for (int i=0; i<this.hiddenNeurons.length; ++i)
            for (int j=0; j<this.hiddenNeurons[0].weights.length; ++j)
                newNet.hiddenNeurons[i].weights[j]=hiddenNeurons[i].weights[j];

        for (int j=0; j<this.outputNeuron.weights.length; ++j)
            newNet.outputNeuron.weights[j] = this.outputNeuron.weights[j];
    
        return newNet;
    }

////////////////////////Accessor Functions///////////////////////
public void setPlayerNum(int num)
{
    this.playerNum = num;
}

public void setOpponent(MancalaNetwork opp)
{
    this.opp = opp;
}

/////////////////////////// Neuron Subclass//////////////////////////
    class Neuron
    {
        double[] weights;
        double[] a;
        double n;
        double s;

        public Neuron(int numInputs)
        {   
            weights = new double[numInputs];
            Random rand = new Random();
            for (int i=0; i<numInputs; ++i)
            {
                weights[i] = rand.nextFloat();
                if (rand.nextInt(2) != 0)
                    weights[i] = -weights[i];
            }
        }

        public double prop(double[] inputs)
        {
            this.a = inputs;
            double sum = 0;
            for (int i=0; i<weights.length; ++i)
                sum += (weights[i]*inputs[i]);
            this.n = sum;
            return transFunc(sum);
        }
        
        public double[] getDelta()
        {
            double[] updates = new double[this.weights.length];
            for (int i=0; i<this.weights.length; ++i)
                updates[i] = weights[i] - this.a[i]*this.s;
            return updates;
        }
        
        public void adjustWeights(double[] newWeights)
        {
            for (int i=0; i<newWeights.length; ++i)
                this.weights[i] += newWeights[i];
        }

        public void normalize()
        {
            double max = 1.0;
            for (int i=0; i<this.weights.length; ++i)
            {
                if (Math.abs(this.weights[i]) > max)
                    max = Math.abs(this.weights[i]);
            }
            
            for (int i=0; i<this.weights.length; ++i)
                this.weights[i] = this.weights[i]/max;
        }
    }
/////////////////////// Delta Subclass /////////////////////////////////
    class Delta
    {
        double[][] weights;

        public Delta(int numNeurons, int numWeights)
        {
            this.weights = new double[numNeurons][numWeights];
        }
        
        public void setWeights(int index, double[] newWeights)
        {
            this.weights[index] = newWeights;
        }

        public void scale(double scaler)
        {
            for (int i=0; i<weights.length; ++i)
                for (int j=0; j<weights[0].length; ++j)
                    weights[i][j] *= scaler;
        }

        public void add(Delta other)
        {
            for (int i=0; i<this.weights.length; ++i)
                for (int j=0; j<this.weights[0].length; ++j)
                    this.weights[i][j] += other.weights[i][j];
        }
    }

//////////////////////// More Functions ///////////////////////////////////
    public int chooseMove(Mancala mancala)
    {
        double oldScore = this.scoreBoard(mancala);
        Mancala temp;
        double tempScore;
        int move = 0;
        double bestScore = Double.NEGATIVE_INFINITY;
        for (int i=0; i<this.NUM_BINS; ++i)
        {
            if (mancala.validMove(this.playerNum,i))
            {
                temp = (Mancala)mancala.clone();
                temp.makeMove(this.playerNum, i);
                tempScore = this.scoreBoard(temp);
                if (tempScore > bestScore)
                {
                    bestScore = tempScore;
                    move = i;
                }
            }
        }
        this.bprop(bestScore-oldScore);
        this.updateDeltas();
        //System.out.println("Move: "+move+"\nScore: "+bestScore);
        return move;
    }

    public void gameOver(Mancala mancala, double score)
    {
        double oldScore = this.scoreBoard(mancala);
        this.bprop(score-oldScore);
        this.updateDeltas();
        this.updateNetwork();
        /*
        for (int i=0; i<inputNeurons.length; ++i)
            inputNeurons[i].normalize();
        for (int i=0; i<hiddenNeurons.length; ++i)
            hiddenNeurons[i].normalize();
        outputNeuron.normalize();
        */
    }
    
    public double scoreBoard(Mancala mancala)
    {
        //construct input array
        double[][] input = new double[2*this.NUM_BINS][this.MAX_STONES];
        for (int i=0; i<this.NUM_BINS; ++i)
        {
            input[i] = numToBitArray(mancala.getBins()[0][i], this.MAX_STONES);
            input[i+this.NUM_BINS] = numToBitArray(mancala.getBins()[1][i],
                                                   this.MAX_STONES);
        }
        double score = this.fprop(input);
        return score;
    }

    public double fprop(double[][] input)
    {
        double[] hiddenInputs = new double[2*this.NUM_BINS];
        for (int i=0; i<2*this.NUM_BINS; ++i)
            hiddenInputs[i] = this.inputNeurons[i].prop(input[i]);
        double[] hiddenOutputs = new double[this.NUM_HIDDEN_NEURONS];
        for (int i=0; i<this.NUM_HIDDEN_NEURONS; ++i)
            hiddenOutputs[i] = this.hiddenNeurons[i].prop(hiddenInputs);
        return this.outputNeuron.prop(hiddenOutputs);
    }

    public void bprop(double error)
    {
        this.outputNeuron.s = -2*dtransFunc(this.outputNeuron.n)*error;
        for (int i=0; i<this.NUM_HIDDEN_NEURONS; ++i)
        {
            this.hiddenNeurons[i].s = dtransFunc(this.hiddenNeurons[i].n)*
                                    this.outputNeuron.weights[i]*
                                    this.outputNeuron.s;
        }
        for (int i=0; i<2*this.NUM_BINS; ++i)
        {
            double sens = 0.0;
            for (int j=0; j<this.NUM_HIDDEN_NEURONS; ++j)
            {
                sens += this.hiddenNeurons[j].weights[i]*
                        this.hiddenNeurons[j].s;
            }
            this.inputNeurons[i].s = dtransFunc(this.inputNeurons[i].n)*sens;
        }
    }

    public void updateDeltas()
    {
        this.inputDelta.scale(this.LAMBDA);
        for (int i=0; i<2*this.NUM_BINS; ++i)
            this.inputDelta.setWeights(i, this.inputNeurons[i].getDelta());
        this.inputDeltaAcc.add(this.inputDelta);

        this.hiddenDelta.scale(this.LAMBDA);
        for (int i=0; i<this.NUM_HIDDEN_NEURONS; ++i)
            this.hiddenDelta.setWeights(i, this.hiddenNeurons[i].getDelta());
        this.hiddenDeltaAcc.add(this.hiddenDelta);
        
        this.outputDelta.scale(this.LAMBDA);
        this.outputDelta.setWeights(0, this.outputNeuron.getDelta());
        this.outputDeltaAcc.add(this.outputDelta);
    }

    public void updateNetwork()
    {
        this.inputDeltaAcc.scale(this.ALPHA);
        for (int i=0; i<2*this.NUM_BINS; ++i)
            this.inputNeurons[i].adjustWeights(this.inputDeltaAcc.weights[i]);
        
        this.hiddenDeltaAcc.scale(this.ALPHA);
        for (int i=0; i<this.NUM_HIDDEN_NEURONS; ++i)
            this.hiddenNeurons[i].adjustWeights(this.hiddenDeltaAcc.weights[i]);
        
        this.outputDeltaAcc.scale(this.ALPHA);
        this.outputNeuron.adjustWeights(this.outputDeltaAcc.weights[0]);
    }

    private static double[] numToBitArray(int num, int padding)
    {
        if (num>padding)
            System.err.println("TOO MANY STONES FOR NETWORK TO HANDLE ("+num+")");
        double[] array = new double[padding];
        for (int i=0; i<num; ++i)
            array[i] = 1.0;
        for (int i=num; i<padding; ++i)
            array[i] = 0.0;
        return array;
    }

////////////////////// Sigmoid Functions //////////////////////////
    
    //Chosen transfer function
    private static double transFunc(double i)
    {
        return 2.0/(1.0+Math.exp(-2.0*i))-1.0;
    }
    
    //Derivative of chosen transfer function
    private static double dtransFunc(double i)
    {
        double num = 2*Math.exp(i/5);
        double denom = 5*(1+Math.exp(i/5));
        return num/(denom*denom);
    }
}