package main

import (
	v "bitbucket.org/hackerbots/vector"
	"code.google.com/p/go.net/websocket"
	"log"
	"math"
	"math/rand"
)

type player struct {
	ws          *websocket.Conn
	Robot       Robot
	send        chan *Boardstate
	Instruction Instruction
}

func (p *player) sender() {
	for things := range p.send {
		err := websocket.JSON.Send(p.ws, *things)
		if err != nil {
			break
		}
	}
	p.ws.Close()
	log.Printf("player %s: sender close", p.Robot.Id)
}

func (p *player) recv() {
	for {
		// XXX: need to mark myself as having received something, also binding
		// such action to a particular game turn ID
		var msg Instruction
		err := websocket.JSON.Receive(p.ws, &msg)
		if err != nil {
			// TODO: perhaps we could be a bit more precise in the handling of
			// this 'error' by selecting on some kill signal channel and this
			// json read?
			log.Print("problem receiving JSON from player: ", err)
			break
		}
		if msg.MoveTo != nil {
			p.Robot.MoveTo = msg.MoveTo
		}
		if msg.FireAt != nil {
			p.Robot.FireAt = msg.FireAt
		}

		p.Robot.TargetSpeed = p.Robot.Stats.Speed

		if msg.Stats.Speed > 0 {
			p.Robot.Stats = msg.Stats
			p.Robot.Health = p.Robot.Stats.Hp
			p.Robot.Speed = 0
			p.Robot.TargetSpeed = p.Robot.Stats.Speed
		}
	}
	log.Printf("player %s: recv close", p.Robot.Id)
	p.ws.Close()
}

func (p *player) checkCollisions(g *game, move_vector v.Vector2d) (bool, v.Point2d) {
	collision := false
	intersection_point := v.Point2d{X: 0, Y: 0}

	// Check Walls
	r_walls := v.Rect2d{A: v.Point2d{X: 0, Y: 0}, B: v.Point2d{X: g.width, Y: g.height}}
	collision, _, pos := v.RectIntersection(r_walls, p.Robot.Position, move_vector)
	if collision {
		return collision, pos
	}

	// Check Other Bots

	// Check Terrain
	// TBD

	return collision, intersection_point
}

func (p *player) nudge(g *game) {

	// Adjust Speed
	if p.Robot.Speed < p.Robot.TargetSpeed {
		p.Robot.Speed += (p.Robot.Stats.Acceleration * delta)
	} else if (p.Robot.Speed - p.Robot.TargetSpeed) > v.Epsilon {
		p.Robot.Speed -= (p.Robot.Stats.Acceleration * delta)
	} else {
		p.Robot.Speed = p.Robot.TargetSpeed
	}

	// Adjust Heading
	current_heading := p.Robot.Heading
	if current_heading.Mag() == 0 {
		// We may have been stopped before this and had no heading
		current_heading = p.Robot.MoveTo.Sub(p.Robot.Position).Normalize()
	}

	// Where do we WANT to be heading?
	new_heading := p.Robot.MoveTo.Sub(p.Robot.Position).Normalize()

	// Is our direction change too much? Hard coding to 5 degrees/s for now
	angle := v.Angle(current_heading, new_heading) * v.Rad2deg
	dir := 1.0
	if angle < 0 {
		dir = -1.0
	}

	// Max turn radius in this case is 100 degrees per second
	if math.Abs(angle) > (100 * delta) {
		// New heading should be a little less, take current heading and
		// rotate by the max turn radius per frame.
		rot := (100 * delta) * v.Deg2rad

		new_heading = current_heading.Rotate(rot * dir)
	}

	move_vector := new_heading.Scale(p.Robot.Speed * delta)
	collision, _ := p.checkCollisions(g, move_vector)
	if collision {
		// p.Robot.Position = intersection_point
		p.Robot.Speed = 0
		p.Robot.MoveTo = &p.Robot.Position
		p.Robot.Health -= 5
		p.Robot.Heading = v.Vector2d{X: 0, Y: 0}
	} else {
		p.Robot.Position = p.Robot.Position.Add(move_vector)
		if new_heading.Mag() > 0 {
			p.Robot.Heading = new_heading
		} else {
			log.Printf("Zero Heading %v", new_heading)
		}
	}
}

func (p *player) scan(players map[*player]bool) {
	p.Robot.Scanners = p.Robot.Scanners[:0]
	for player, _ := range players {
		if player.Robot.Id == p.Robot.Id || player.Robot.Health <= 0 {
			continue
		}
		dist := v.Distance(player.Robot.Position, p.Robot.Position)
		if dist < float64(p.Robot.Stats.ScannerRadius) {
			s := Scanner{
				Position: v.Point2d{
					X: player.Robot.Position.X,
					Y: player.Robot.Position.Y,
				},
			}
			p.Robot.Scanners = append(p.Robot.Scanners, s)
		}
	}
}

func (p *player) fire(projectiles map[*Projectile]bool) *Projectile {
	// XXX: is this to prevent us from having multiple projectiles from the
	// same bot?
	for proj := range projectiles {
		if proj.Id == p.Robot.Id {
			return nil
		}
	}

	return &Projectile{
		Id:       p.Robot.Id,
		Position: p.Robot.Position,
		MoveTo:   *p.Robot.FireAt,
		Damage:   10,
		Radius:   p.Robot.Stats.WeaponRadius,
		Speed:    float64(p.Robot.Stats.Speed * 2),
	}
}

func (p *player) reset() {
	start_pos := v.Point2d{
		X: rand.Float64() * *width,
		Y: rand.Float64() * *height,
	}
	p.Robot.MoveTo = &start_pos
	p.Robot.Position = start_pos
	p.Robot.Health = p.Robot.Stats.Hp
}