use scene;
use tile;
use view;
use vr;
use world as model;
use world::HasMap;

extern crate gfx;
extern crate nalgebra as na;
extern crate num_traits;
extern crate openvr_sys;
extern crate piston_window;

use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::time::SystemTime;

use gfx::tex;
use gfx::traits::FactoryExt;
use self::na::ToHomogeneous;
use self::num_traits::identities::One;

//const R1: f32 = 4096.0;
//const R2: f32 = 1024.0;
//const R1: f32 = 4.0;
//const R2: f32 = 1.0;
const R1: f32 = 256.0;
const R2: f32 = 64.0;

gfx_defines! {
  vertex Vertex {
    pos: [f32; 3] = "a_pos",
    uv: [f32; 2] = "a_uv",
    tileidx: u32 = "a_tileidx",
  }

  constant Constants {
    anim: u32 = "anim",
    r1: f32 = "R1",
    r2: f32 = "R2",
  }

  constant Locals {
    camera: [[f32; 4]; 4] = "camera",
    millis: u32 = "millis",
    treadmill_x: f32 = "treadmill_x",
    treadmill_y: f32 = "treadmill_y",
  }

  pipeline pipe {
    vbuf: gfx::VertexBuffer<Vertex> = (),
    trans: gfx::ConstantBuffer<::view::Trans> = "b_trans",
    constants: gfx::ConstantBuffer<Constants> = "b_constants",
    locals: gfx::ConstantBuffer<Locals> = "b_locals",
    atlas: gfx::TextureSampler<[f32; 4]> = "t_atlas",
    pixcolor: gfx::RenderTarget<::view::ColorFormat> = "pixcolor",
    depth: gfx::DepthTarget<::view::DepthFormat> = gfx::preset::depth::LESS_EQUAL_WRITE,
  }
}


fn get_model(world: &model::World) -> (Vec<Vertex>, Vec<u32>) {
  let mut verticies = Vec::new();
  let mut indicies = Vec::new();
  let mut v = 0;

  for (r, row) in world.map().rows().enumerate() {
    for (c, tile) in row.into_iter().enumerate() {
      let tileidx = tile.val as u32;
      let alt = match tileidx {
        5 => 0.1,
        6 => 0.8,
        7 => 0.2,
        8 => 1.5,
        9 => 1.0,
        10 | 11 | 12 => 1.0,
        _ => 0.0,
      };
      let rf = (((r + 90) % 256) as i16 - 128) as f32;
      let cf = (((c + 144) % 256) as i16 - 128) as f32;
      if alt == 0.0 {
        verticies.extend_from_slice(
          &[Vertex { pos: [ cf + 0., -rf - 1., 0. ], uv: [0., 0.], tileidx: tileidx },
            Vertex { pos: [ cf + 1., -rf - 1., 0. ], uv: [1., 0.], tileidx: tileidx },
            Vertex { pos: [ cf + 1., -rf - 0., 0. ], uv: [1., 1.], tileidx: tileidx },
            Vertex { pos: [ cf + 0., -rf - 0., 0. ], uv: [0., 1.], tileidx: tileidx },]);
        indicies.extend_from_slice(
          &[ v + 0, v + 1, v + 2,
             v + 2, v + 3, v + 0 ]);
        v += 4;
      } else {
        verticies.extend_from_slice(
          &[Vertex { pos: [ cf + 0., -rf - 1., 0. ], uv: [0., 0.], tileidx: 126 },
            Vertex { pos: [ cf + 1., -rf - 1., 0. ], uv: [1., 0.], tileidx: 126 },
            Vertex { pos: [ cf + 1., -rf - 0., 0. ], uv: [1., 1.], tileidx: 126 },
            Vertex { pos: [ cf + 0., -rf - 0., 0. ], uv: [0., 1.], tileidx: 126 },
            Vertex { pos: [ cf + 0., -rf, 0. ], uv: [0., 0.], tileidx: tileidx },
            Vertex { pos: [ cf + 1., -rf, 0. ], uv: [1., 0.], tileidx: tileidx },
            Vertex { pos: [ cf + 1., -rf, alt ], uv: [1., 1.], tileidx: tileidx },
            Vertex { pos: [ cf + 0., -rf, alt ], uv: [0., 1.], tileidx: tileidx },]);
        indicies.extend_from_slice(
          &[ v + 0, v + 1, v + 2,
             v + 2, v + 3, v + 0,
             v + 4, v + 5, v + 6,
             v + 6, v + 7, v + 4 ]);
        v += 8;
      }
    }
  }
  (verticies, indicies)
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum TrackMode {
  TOUCH,
  PRESS
}

pub struct WorldScene<D: gfx::Device,
                      F: gfx::Factory<D::Resources>> {
  pso: gfx::PipelineState<D::Resources, pipe::Meta>,
  camera: na::Matrix4<f32>,
  constants: gfx::handle::Buffer<D::Resources, Constants>,
  locals: gfx::handle::Buffer<D::Resources, Locals>,
  atlas: gfx::handle::ShaderResourceView<D::Resources,
                                         <view::ColorFormat as gfx::format::Formatted>::View>,
  sampler: gfx::handle::Sampler<D::Resources>,
  f: PhantomData<F>,

  vbuf: gfx::handle::Buffer<D::Resources, Vertex>,
  slice: gfx::Slice<D::Resources>,

  start_time: SystemTime,
  treadmills: (f32, f32),
  pads: BTreeMap<u32, (TrackMode, Option<openvr_sys::VRControllerState_t>)>,
}

impl<D: gfx::Device, F: gfx::Factory<D::Resources>> WorldScene<D, F> {
  pub fn new(factory: &mut F,
             encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) -> WorldScene<D, F> {
    let (model, model_idx) = get_model(&get_data_model());
    let (vertex_buffer, slice) =
        factory.create_vertex_buffer_with_slice(&model, &model_idx[..]);

    let constants = factory.create_constant_buffer(1);
    encoder.update_constant_buffer(&constants, &Constants { anim: ANIMDATA[0],
                                                            r1: R1,
                                                            r2: R2 });

    WorldScene {
      pso: factory.create_pipeline_simple(VERTEX_SHADER_SRC,
                                          FRAGMENT_SHADER_SRC,
                                          pipe::new())
                  .expect("create pipeline"),
      camera: na::Matrix4::one(),
      constants: constants,
      locals: factory.create_constant_buffer(1),
      atlas: tile::get_tiles::<_, _, view::ColorFormat>(factory),
      sampler: factory.create_sampler(tex::SamplerInfo::new(tex::FilterMethod::Scale,
                                                            tex::WrapMode::Clamp)),
      f: PhantomData,

      vbuf: vertex_buffer,
      slice: slice,
      start_time: SystemTime::now(),
      treadmills: (0.0, 0.0),
      pads: BTreeMap::new(),
    }
  }
}

const ANIMDATA: [u32; 4] =
  [1 << 0 | 1 << 1 | 1 << 2,
   0,
   1 << (68 % 32) | 1 << (69 % 32) | 1 << (70 % 32) | 1 << (71 % 32) | 1 << (76 % 32),
   0];

impl<D: gfx::Device,
     F: gfx::Factory<D::Resources>> scene::Scene<D, F> for WorldScene<D, F> {

  fn event(&mut self, event: scene::Event) {
    use scene::Event::*;
    use vr::Event::*;
    match event {
      Vr(Touch { dev_idx, controller }) => {
        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
      },
      Vr(Press { dev_idx, controller }) => {
        self.pads.insert(dev_idx, (TrackMode::PRESS, None));
      },
      Vr(Unpress { dev_idx, controller }) => {
        self.pads.insert(dev_idx, (TrackMode::TOUCH, None));
      },
      Vr(Untouch { dev_idx, controller }) => {
        self.pads.remove(&dev_idx);
      },
      _ => ()
    }
  }

  fn update(&mut self,
            vr: &mut vr::VR,
            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>) {
    const NANOS_PER_MILLI: u32 = 1_000_000;
    const MILLIS_PER_SEC: u64 = 1_000;
    let elapsed = self.start_time.elapsed().expect("scene timer");
    let millis = elapsed.subsec_nanos() / NANOS_PER_MILLI + (elapsed.as_secs() * MILLIS_PER_SEC) as u32;

    for (pad, track) in self.pads.iter_mut() {
      let mode = track.0;
      if let Some(state) = vr.get_controller_state(*pad) {
        if let Some(old_state) = track.1 {
          match mode {
            TrackMode::TOUCH => {
              const THRESHOLD: f32 = 0.005;
              const SCALE: f32 = 32.0;
              let xdiff = state.rAxis[0].x - old_state.rAxis[0].x;
              let ydiff = state.rAxis[0].y - old_state.rAxis[0].y;
              if xdiff.abs() > THRESHOLD { self.treadmills.0 += SCALE * xdiff; }
              if ydiff.abs() > THRESHOLD { self.treadmills.1 += SCALE * ydiff; }
            },
            TrackMode::PRESS => {
              let rot = na::Vector3::new(0.0, 0.0, 0.0);
              let speed = R2 * 0.01;
              if state.rAxis[0].x > 0.5 {
                self.camera = na::Similarity3::new(na::Vector3::new(-speed,  0.0, 0.0),
                                                   rot, 1.0).to_homogeneous() * self.camera;
              } if state.rAxis[0].x < -0.5 {
                self.camera = na::Similarity3::new(na::Vector3::new( speed,  0.0, 0.0),
                                                    rot, 1.0).to_homogeneous() * self.camera;
              } if state.rAxis[0].y >  0.5 {
                self.camera = na::Similarity3::new(na::Vector3::new( 0.0, -speed, 0.0),
                                                    rot, 1.0).to_homogeneous() * self.camera;
              } if state.rAxis[0].y < -0.5 {
                self.camera = na::Similarity3::new(na::Vector3::new( 0.0,  speed, 0.0),
                                                    rot, 1.0).to_homogeneous() * self.camera;
              }
            },
          }

          if state.unPacketNum == old_state.unPacketNum {
            continue;
          }
        }
        *track = (mode, Some(state));
      }
    }

    encoder.update_constant_buffer(&self.locals, &Locals { camera: *(self.camera).as_ref(),
                                                           millis: millis,
                                                           treadmill_x: self.treadmills.0,
                                                           treadmill_y: self.treadmills.1 });
  }

  fn render(&self,
            _factory: &mut F,
            encoder: &mut gfx::Encoder<D::Resources, D::CommandBuffer>,
            trans: &gfx::handle::Buffer<D::Resources, view::Trans>,
            target: &gfx::handle::RenderTargetView<D::Resources, view::ColorFormat>,
            depth: &gfx::handle::DepthStencilView<D::Resources, view::DepthFormat>) {

    let pipe = pipe::Data {
      vbuf: self.vbuf.clone(),
      trans: trans.clone(),
      constants: self.constants.clone(),
      locals: self.locals.clone(),
      atlas: (self.atlas.clone(), self.sampler.clone()),
      pixcolor: target.clone(),
      depth: depth.clone(),
    };
    encoder.draw(&self.slice, &self.pso, &pipe);
  }

  fn origin(&self) -> na::Matrix4<f32> {
    na::Similarity3::new(na::Vector3::new(0.0, R1 - R2, 0.0),
                         na::Vector3::new(0.0, 0.0, 0.0), 1.0).to_homogeneous()

  }
}

extern crate memmap;
fn get_data_model() -> model::World {
  use self::memmap::{Mmap, Protection};
  use std::mem::transmute;

  fn mmap_to_rows<'a, M: model::HasMap>(mmap: &memmap::Mmap) -> &'a M
    where M: Copy + 'a
  {
    assert_eq!(::std::mem::size_of::<M>(), mmap.len());
    unsafe { transmute::<*const u8, &M>(mmap.ptr()) }
  }

  let filename = "data/WORLD.MAP";
  let file_mmap = Mmap::open_path(filename, Protection::Read).unwrap();
  mmap_to_rows::<model::World>(&file_mmap).clone()
}

const VERTEX_SHADER_SRC: &'static [u8] = include_bytes!("shader/torus_vertex.glsl");
const FRAGMENT_SHADER_SRC: &'static [u8] = include_bytes!("shader/tile_frag.glsl");