/*
 * KiRouter - a push-and-(sometimes-)shove PCB router
 *
 * Copyright (C) 2013  CERN
 * Author: Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.or/licenses/>.
 */

#include "pns_via.h"
#include "pns_node.h"
#include "pns_utils.h"

#include <geometry/shape_rect.h>

static bool Circle2Circle( VECTOR2I p1, VECTOR2I p2, int r1, int r2, VECTOR2I& force )
{
    int mindist = r1 + r2;
    VECTOR2I delta = p2 - p1;
    int dist = delta.EuclideanNorm();

    if( dist >= mindist )
        return false;

    force = delta.Resize( abs( mindist - dist ) + 1 );
    return true;
};

static bool Rect2Circle( VECTOR2I rp0, VECTOR2I rsize, VECTOR2I cc, int cr, VECTOR2I& force )
{
    VECTOR2I vts[] =
    {
        VECTOR2I( rp0.x,           rp0.y ),
        VECTOR2I( rp0.x,           rp0.y + rsize.y ),
        VECTOR2I( rp0.x + rsize.x, rp0.y + rsize.y ),
        VECTOR2I( rp0.x + rsize.x, rp0.y ),
        VECTOR2I( rp0.x,           rp0.y )
    };

    int dist = INT_MAX;
    VECTOR2I nearest;

    for( int i = 0; i < 4; i++ )
    {
        SEG s( vts[i], vts[i + 1] );

        VECTOR2I pn = s.NearestPoint( cc );

        int d = (pn - cc).EuclideanNorm();

        if( d < dist )
        {
            nearest = pn;
            dist = d;
        }
    }

    bool inside = cc.x >= rp0.x && cc.x <= (rp0.x + rsize.x)
                  && cc.y >= rp0.y && cc.y <= (rp0.y + rsize.y);

    VECTOR2I delta = cc - nearest;

    if( dist >= cr && !inside )
        return false;

    if( inside )
        force = -delta.Resize( abs( cr + dist ) + 1 );
    else
        force = delta.Resize( abs( cr - dist ) + 1 );

    return true;
};


static bool ShPushoutForce( const SHAPE* shape, VECTOR2I p, int r, VECTOR2I& force, int clearance )
{
    switch( shape->Type() )
    {
    case SH_CIRCLE:
        {
            const SHAPE_CIRCLE* cir = static_cast<const SHAPE_CIRCLE*>(shape);
            return Circle2Circle( cir->GetCenter(), p, cir->GetRadius(), r + clearance + 1, force );
        }

    case SH_RECT:
        {
            const SHAPE_RECT* rect = static_cast<const SHAPE_RECT*>(shape);
            return Rect2Circle( rect->GetPosition(), rect->GetSize(), p, r + clearance + 1, force );
        }

    default:
        return false;
    }

    return false;
}


bool PNS_VIA::PushoutForce( PNS_NODE* aNode,
        const VECTOR2I& aDirection,
        VECTOR2I& aForce,
        bool aSolidsOnly,
        int aMaxIterations )
{
    int iter = 0;
    PNS_VIA mv( *this );
    VECTOR2I force, totalForce;

    while( iter < aMaxIterations )
    {
        PNS_NODE::OptObstacle obs = aNode->CheckColliding( &mv,
                aSolidsOnly ? PNS_ITEM::SOLID : PNS_ITEM::ANY );

        if( !obs )
            break;

        int clearance = aNode->GetClearance( obs->item, &mv );

        if( iter > 10 )
        {
            VECTOR2I l = -aDirection.Resize( m_diameter / 4 );
            totalForce += l;
            mv.SetPos( mv.GetPos() + l );
        }

        if( ShPushoutForce( obs->item->GetShape(), mv.GetPos(), mv.GetDiameter() / 2, force,
                    clearance ) )
        {
            totalForce += force;
            mv.SetPos( mv.GetPos() + force );
        }


        iter++;
    }

    if( iter == aMaxIterations )
        return false;

    aForce = totalForce;
    return true;
}


const SHAPE_LINE_CHAIN PNS_VIA::Hull( int aClearance, int aWalkaroundThickness ) const
{
    return OctagonalHull( m_pos -
            VECTOR2I( m_diameter / 2, m_diameter / 2 ), VECTOR2I( m_diameter,
                    m_diameter ), aClearance + 1, (2 * aClearance + m_diameter) * 0.26 );
}