#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "monsters.h"
#include "weapons.h"
#include "nodes.h"
#include "player.h"
#include "gamerules.h"

#define    PW_BODYHIT_VOLUME 128
#define    PW_WALLHIT_VOLUME 512

#define PWAT_PRIMARY  2
#define PWAT_SECONDARY  1
#define PWAT_NONE   0

#define PWSA_NO    0
#define PWSA_RISING   1
#define PWSA_LOOP   2
#define PWSA_HITING   3

LINK_ENTITY_TO_CLASS( weapon_pipewrench, CPW );

enum pw_e {
  PW_IDLE = 0,
  PW_IDLE2,
  PW_IDLE3,
  PW_DRAW,
  PW_HOLSTER,
  PW_ATTACK1HIT,
  PW_ATTACK1MISS,
  PW_ATTACK2HIT,
  PW_ATTACK2MISS,
  PW_ATTACK3HIT,
  P W_ATTACK3MISS,
  PW_RISE,
  PW_RISEN_HIT,
  PW_RISEN_MISS,
  PW_RISEN
};

void CPW::Spawn( )
{
  Precache( );
  m_iId = WEAPON_PW;
  SET_MODEL(ENT(pev), "models/w_pipe_wrench.mdl");
  m_iClip = -1;
  FallInit();// get ready to fall down.
}

void CPW::Precache( void )
{
  PRECACHE_MODEL("models/v_pipe_wrench.mdl");
  PRECACHE_MODEL("models/w_pipe_wrench.mdl");
  PRECACHE_MODEL("models/p_pipe_wrench.mdl");

  PRECACHE_SOUND("weapons/pwrench_hit1.wav");
  PRECACHE_SOUND("weapons/pwrench_hit2.wav");
  PRECACHE_SOUND("weapons/pwrench_hitbod1.wav");
  PRECACHE_SOUND("weapons/pwrench_hitbod2.wav");
  PRECACHE_SOUND("weapons/pwrench_hitbod3.wav");
  PRECACHE_SOUND("weapons/pwrench_big_hit1.wav");
  PRECACHE_SOUND("weapons/pwrench_big_hit2.wav");
  PRECACHE_SOUND("weapons/pwrench_big_hitbod1.wav");
  PRECACHE_SOUND("weapons/pwrench_big_hitbod2.wav");
  PRECACHE_SOUND("weapons/pwrench_big_miss.wav");
  PRECACHE_SOUND("weapons/pwrench_miss1.wav");
  PRECACHE_SOUND("weapons/pwrench_miss2.wav");

  m_usPW = PRECACHE_EVENT ( 1, "events/pipewrench.sc" );
}

int CPW::GetItemInfo(ItemInfo *p)
{
  p->pszName = STRING(pev->classname);
  p->pszAmmo1 = NULL;
  p->iMaxAmmo1 = -1;
  p->pszAmmo2 = NULL;
  p->iMaxAmmo2 = -1;
  p->iMaxClip = WEAPON_NOCLIP;
  p->iSlot = 0;
  p->iPosition = 2;
  p->iId = WEAPON_PW;
  p->iWeight = PW_WEIGHT;
  return 1;
}
void FindHullIntersection3( const Vector &vecSrc, TraceResult &tr, float *mins, float *maxs, edict_t *pEntity )
{
  int   i, j, k;
  float  distance;
  float  *minmaxs[2] = {mins, maxs};
  TraceResult tmpTrace;
  Vector  vecHullEnd = tr.vecEndPos;
  Vector  vecEnd;

  distance = 1e6f;

  vecHullEnd = vecSrc + ((vecHullEnd - vecSrc)*2);
  UTIL_TraceLine( vecSrc, vecHullEnd, dont_ignore_monsters, pEntity, &tmpTrace );
  if ( tmpTrace.flFraction < 1.0 )
  {
   tr = tmpTrace;
   return;
  }

  for ( i = 0; i < 2; i++ )
  {
   for ( j = 0; j < 2; j++ )
   {
    for ( k = 0; k < 2; k++ )
    {
     vecEnd.x = vecHullEnd.x + minmaxs[i][0];
     vecEnd.y = vecHullEnd.y + minmaxs[j][1];
     vecEnd.z = vecHullEnd.z + minmaxs[k][2];

     UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, pEntity, &tmpTrace );
     if ( tmpTrace.flFraction < 1.0 )
     {
      float thisDistance = (tmpTrace.vecEndPos - vecSrc).Length();
      if ( thisDistance < distance )
      {
       tr = tmpTrace;
       distance = thisDistance;
      }
     }
    }
   }
  }
}

BOOL CPW::Deploy( )
{
  return DefaultDeploy( "models/v_pipe_wrench.mdl", "models/p_pipe_wrench.mdl", PW_DRAW, "pipe_wrench" );
}

void CPW::Holster( int skiplocal /* = 0 */ )
{
  m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + 0.5;
  SendWeaponAnim( PW_HOLSTER );

  iSAttack    = 0;
  m_tAttack    = 0;
}

void CPW::SecondaryAttack()
{
  switch (iSAttack)
  {
  case PWSA_NO:
   iSAttack = PWSA_RISING;
   return;
   break;
  case PWSA_RISING:
   SendWeaponAnim( PW_RISE );
   iSAttack = PWSA_LOOP;
   break;
  case PWSA_LOOP:
   SendWeaponAnim( PW_RISEN );
   if(!m_pPlayer->m_afButtonPressed)
    iSAttack = PWSA_HITING;
   else iSAttack = PWSA_LOOP;
   break;
  case PWSA_HITING:
   if (Swing( 1 ))
     SendWeaponAnim( PW_RISEN_HIT );
   else SendWeaponAnim( PW_RISEN_MISS );
   break;
  }
  m_tAttack = PWAT_SECONDARY;
}

void CPW::PrimaryAttack()
{
  if(! ( m_pPlayer->m_afButtonPressed & IN_ATTACK ) )
  return;//SEMI_AUTO
  m_tAttack = PWAT_PRIMARY;
  if (! Swing( 1 ))
  {
   SetThink( SwingAgain );
   pev->nextthink = gpGlobals->time + 0.1;
  }
}

void CPW::Smack( )
{
  if (m_tAttack == PWAT_PRIMARY)  
    DecalGunshot( &m_trHit, BULLET_PLAYER_PW );
  else DecalGunshot( &m_trHit, BULLET_PLAYER_PW2 );
}

void CPW::SwingAgain( void )
{
  Swing( 0 );
}

int CPW::Swing( int fFirst )
{
  int fDidHit = FALSE;
  TraceResult tr;
  UTIL_MakeVectors (m_pPlayer->pev->v_angle);
  Vector vecSrc    = m_pPlayer->GetGunPosition( );
  Vector vecEnd    = vecSrc + gpGlobals->v_forward * 32;
  UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );
#ifndef CLIENT_DLL
  if ( tr.flFraction >= 1.0 )
  {
   UTIL_TraceHull( vecSrc, vecEnd, dont_ignore_monsters, head_hull, ENT( m_pPlayer->pev ), &tr );
   if ( tr.flFraction < 1.0 )
   {
    // Calculate the point of intersection of the line (or hull) and the object we hit
    // This is and approximation of the "best" intersection
    CBaseEntity *pHit = CBaseEntity::Instance( tr.pHit );
    if ( !pHit || pHit->IsBSPModel() )
     FindHullIntersection3( vecSrc, tr, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, m_pPlayer->edict() );
    vecEnd = tr.vecEndPos;    // This is the point on the actual surface (the hull could have hit space)
   }
  }
#endif
  PLAYBACK_EVENT_FULL( FEV_NOTHOST, m_pPlayer->edict(), m_usPW, 0.0, (float *)&g_vecZero, (float *)&g_vecZero, 0, 0, 0, 0.0, 0, 0.0 );
  if ( tr.flFraction >= 1.0 )
  {
   if (fFirst)
   {
    // miss
    m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.5;
     
    // player "shoot" animation
    m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
   }
  }
  else
  {
   switch( ((m_iSwing++) % 2) + 1 )
   {
   case 0:
    SendWeaponAnim( PW_ATTACK1HIT ); break;
   case 1:
    SendWeaponAnim( PW_ATTACK2HIT ); break;
   case 2:
    SendWeaponAnim( PW_ATTACK3HIT ); break;
   }

   // player "shoot" animation
   m_pPlayer->SetAnimation( PLAYER_ATTACK1 );
    
#ifndef CLIENT_DLL

   // hit
   fDidHit = TRUE;
   CBaseEntity *pEntity = CBaseEntity::Instance(tr.pHit);

   ClearMultiDamage( );

   if ( (m_flNextPrimaryAttack + 1 < UTIL_WeaponTimeBase() ) || g_pGameRules->IsMultiplayer() )
   {
    if (m_tAttack == PWAT_PRIMARY)
    // first swing does full damage
    pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgPW, gpGlobals->v_forward, &tr, DMG_CLUB );  
    else pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgPW2, gpGlobals->v_forward, &tr, DMG_CLUB );  
   }
   else
   {
   if (m_tAttack == PWAT_PRIMARY)
    pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgPW / 2, gpGlobals->v_forward, &tr, DMG_CLUB );  
    else pEntity->TraceAttack(m_pPlayer->pev, gSkillData.plrDmgPW2 / 2, gpGlobals->v_forward, &tr, DMG_CLUB );  
   }  
   ApplyMultiDamage( m_pPlayer->pev, m_pPlayer->pev );

   // play thwack, smack, or dong sound
   float flVol = 1.0;
   int fHitWorld = TRUE;
   if (pEntity)
   {
    if ( pEntity->Classify() != CLASS_NONE && pEntity->Classify() != CLASS_MACHINE )
    {
     // play thwack or smack sound
     switch( RANDOM_LONG(0,2) )
     {
     case 0:
      EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/pwrench_hitbod1.wav", 1, ATTN_NORM); break;
     case 1:
      EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/pwrench_hitbod2.wav", 1, ATTN_NORM); break;
     case 2:
      EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/pwrench_hitbod3.wav", 1, ATTN_NORM); break;
     }
     m_pPlayer->m_iWeaponVolume = PW_BODYHIT_VOLUME;
     if ( !pEntity->IsAlive() )
        return TRUE;
     else
        flVol = 0.1;
     fHitWorld = FALSE;
    }
   }
   if (fHitWorld)
   {
    float fvolbar = TEXTURETYPE_PlaySound(&tr, vecSrc, vecSrc + (vecEnd-vecSrc)*2, BULLET_PLAYER_PW);
    if ( g_pGameRules->IsMultiplayer() )
    {
     fvolbar = 1;
    }
    // also play pipewrench strike
    switch( RANDOM_LONG(0,1) )
    {
    case 0:
     EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/pwrench_hit1.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG(0,3));  
     break;
    case 1:
     EMIT_SOUND_DYN(ENT(m_pPlayer->pev), CHAN_ITEM, "weapons/pwrench_hit2.wav", fvolbar, ATTN_NORM, 0, 98 + RANDOM_LONG(0,3));  
     break;
    }

    // delay the decal a bit
    m_trHit = tr;
   }

   m_pPlayer->m_iWeaponVolume = flVol * PW_WALLHIT_VOLUME;
#endif
   m_flNextPrimaryAttack = UTIL_WeaponTimeBase() + 0.25;
   SetThink( Smack );
   pev->nextthink = UTIL_WeaponTimeBase() + 0.2;
  }
  return fDidHit;
}