package me.hasunemiku2015.mikumsp;

import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.util.Vector;

import java.util.ArrayList;
import java.util.List;

public class RTX {
    static Material[] rail = new Material[]{Material.ACTIVATOR_RAIL, Material.POWERED_RAIL, Material.DETECTOR_RAIL,
            Material.RAIL};

    public static List<Object> railtest(MovingCart cart, Location next) {
        //1. norailtest 2.next
        List<Object> output = new ArrayList<>();


        State state = cart.getState();

        Location location = cart.getMinecart().getLocation();
        int oldx = cart.getMinecart().getLocation().getBlockX();
        int oldz = cart.getMinecart().getLocation().getBlockZ();
        int newx = next.getBlockX();
        int newz = next.getBlockZ();

        Vector distance_temp = next.toVector().subtract(cart.getMinecart().getLocation().toVector());
        double distance =  distance_temp.length();
        System.out.println(distance);

        Vector valueadd = null;
        boolean norailtest = true;
        try {
            valueadd = motion(location, cart.getState(), distance);
            System.out.println(valueadd);
            location.add(valueadd);
        } catch (Exception e) {
            norailtest = false;
        }

        output.add(norailtest);
        output.add(location);
        return output;


//        boolean norailtest = false;
//        int[] test1 = Util.arrayfromnumberplusminusc(oldx, newx, 0);
//        for (int i : test1) {
//            Location miku = cart.getMinecart().getLocation();
//            miku.setX(i);
//            Material railtest_material = miku.getBlock().getType();
//            boolean blockisrail = false;
//            for (Material raill : rail) {
//                if (railtest_material.equals(raill)) {
//                    blockisrail = true;
//                    break;
//                }
//            }
//
//            if (blockisrail) {
//                Vector valueadd = motion(location, cart.getState(), distance);
//                System.out.println(valueadd);
//                location.add(valueadd);
//                output.add(norailtest);
//                output.add(location);
//
//                return output;
//
//            }else {
//                norailtest = true;
//                output.add(norailtest);
//                output.add(location);
//                return output;
//            }

//            if (blockisrail) {
//                try {
//                    String str = miku.getBlock().getBlockData().getAsString();
//                    System.out.println(str);
//                    if (str.contains("shape=east_west")) {
//                        System.out.println("Good");
//                    } else {
//                        System.out.println("Bad");
//                    }
//                } catch (Exception ignored) {
//                }
//            }
//            if (!blockisrail) {
//                norailtest = true;
//            }
//        }
//        int[] test2 = Util.arrayfromnumberplusminusc(oldz, newz, 0);
//        for (int i : test2) {
//            Location miku = cart.getMinecart().getLocation();
//            miku.setZ(i);
//            Material railtest_material = miku.getBlock().getType();
//            boolean blockisrail = false;
//            for (Material raill : rail) {
//                if (railtest_material.equals(raill)) {
//                    blockisrail = true;
//                    break;
//                }
//            }
//            if (blockisrail) {
//                Vector valueadd = motion(location, cart.getState(), distance);
//                location.add(valueadd);
//                output.add(norailtest);
//                output.add(location);
//
//                return output;
//
//            }else {
//                norailtest = true;
//                output.add(norailtest);
//                output.add(location);
//                return output;
//            }
//       }
//       return new ArrayList<>();
    }

    public static Vector motion(Location l , State direction , double distance){
        Vector pos = l.toVector();
        Vector v = new Vector(0,0,0);
        Vector v2 = new Vector(0,0,0);
//        String s = direction.toString();

        //range is ceiling of distance
        int range = (int) (distance + 1);

        for(int i = 1; i <= range; i++ ){
            switch (direction){
                case EAST: {
                    switch (TrackState.getTrackState(l.add(v2).getBlock().getBlockData().getAsString())){
                        case X_STRAIGHT:
                            v.add(new Vector(1,0,0)); v2.setX(1); v2.setY(0); v2.setZ(0); break;
                        case SOUTH_WEST:
                            v.add(new Vector(1,0,1)); v2.setX(1); v2.setY(0); v2.setZ(1); direction = State.SOUTH; break;
                        case NORTH_WEST:
                            v.add(new Vector(1,0,-1)); v2.setX(1); v2.setY(0); v2.setZ(-1); direction = State.NORTH; break;
                        case EAST_SLOPE:
                            v.add(new Vector(1,1,0)); v2.setX(1); v2.setY(1); v2.setZ(0); break;
                        default:
                            if(TrackState.getTrackState(l.add(v).add(0,-1,0).getBlock().getBlockData().getAsString()) == TrackState.EAST_SLOPE){
                                v.add(new Vector(1,-1,0)); v2.setX(1); v2.setY(-1); v2.setZ(0);
                            } else {
                                throw new IllegalArgumentException();
                            }
                    }
                    break;
                }

                case WEST: {
                    System.out.println(l.add(v2));
                    System.out.println(TrackState.getTrackState(l.add(v2).getBlock().getBlockData().getAsString()));
                    switch (TrackState.getTrackState(l.add(v2).getBlock().getBlockData().getAsString())){
                        case X_STRAIGHT:
                            v.add(new Vector(-1,0,0)); v2.setX(-1); v2.setY(0); v2.setZ(0); break;
                        case SOUTH_EAST:
                            v.add(new Vector(-1,0,1)); direction = State.SOUTH; v2.setX(-1); v2.setY(0); v2.setZ(1); break;
                        case NORTH_EAST:
                            v.add(new Vector(-1,0,-1)); direction = State.NORTH; v2.setX(-1); v2.setY(0); v2.setZ(-1); break;
                        case WEST_SLOPE:
                            v.add(new Vector(-1,1,0)); v2.setX(-1); v2.setY(1); v2.setZ(0); break;
                        default:
                            if(TrackState.getTrackState(l.add(v).add(0,-1,0).getBlock().getBlockData().getAsString()) == TrackState.WEST_SLOPE){
                                v.add(new Vector(-1,-1,0)); v2.setX(-1); v2.setY(-1); v2.setZ(0);
                            } else {
                                throw new IllegalArgumentException();
                            }
                    }
                    break;
                }

                case SOUTH:  {
                    switch (TrackState.getTrackState(l.add(v).getBlock().getBlockData().getAsString())){
                        case Z_STRAIGHT:
                            v.add(new Vector(0,0,1)); break;
                        case NORTH_EAST:
                            v.add(new Vector(1,0,1)); direction = State.EAST; break;
                        case NORTH_WEST:
                            v.add(new Vector(-1,0,1)); direction = State.WEST; break;
                        case SOUTH_SLOPE:
                            v.add(new Vector(0,1,1)); break;
                        default:
                            if(TrackState.getTrackState(l.add(v).add(0,-1,0).getBlock().getBlockData().getAsString()) == TrackState.SOUTH_SLOPE){
                                v.add(new Vector(0,-1,1));
                            } else {
                                throw new IllegalArgumentException();
                            }
                    }
                    break;
                }

                case NORTH: {
                    switch (TrackState.getTrackState(l.add(v).getBlock().getBlockData().getAsString())){
                        case Z_STRAIGHT:
                            v.add(new Vector(0,0,-1)); break;
                        case SOUTH_EAST:
                            v.add(new Vector(1,0,-1)); direction = State.EAST; break;
                        case SOUTH_WEST:
                            v.add(new Vector(-1,0,-1)); direction = State.WEST; break;
                        case NORTH_SLOPE:
                            v.add(new Vector(0,1,-1)); break;
                        default:
                            if(TrackState.getTrackState(l.add(v).add(0,-1,0).getBlock().getBlockData().getAsString()) == TrackState.NORTH_SLOPE){
                                v.add(new Vector(0,-1,-1));
                            } else {
                                throw new IllegalArgumentException();
                            }
                        break;
                    }
                }
            }
        }

        int deltaY = (int) v.getY();
        Vector rectified = v.normalize().multiply(distance);
        rectified.setY(deltaY);
        return rectified;
    }
}