#ifndef _ANT_LIST_HPP_
#define _ANT_LIST_HPP_

#include <math.h>
#include <array>
#include <deque>
#include <tuple>
#include <memory>
#include <algorithm>
#include <sstream>
#include "log.h"
#include "line.h"
#include "point.h"
#include "write-copy.h"
class client;
#include"net-service.h"
#include"common.h"
struct path
{
    std::array<line_v,2>	m_line;
    std::array<double,2>    m_slope;
    path()
    {
        for(auto &d:m_slope)
            d=0;
    }
    std::string to_str() const
    {
        std::stringstream ss;
        for(int i=0;i<2;i++)
        {
            ss<<"line:" <<m_line[i].to_string()<<"slope:"<<m_slope[i]<< " cos:"<<m_line[i].cos()<<" sin:"<<m_line[i].sin()<<" | ";
        }
        return ss.str();
    }
    bool vaild() const
    {
        return !m_line[0].empty();
    }
    line_v & operator[](int i)
    {
        return m_line[i];
    }
    const line_v & operator[](int i) const
    {
        return m_line[i];
    }

};
//?
struct algo_config
{
    const char*desc;
    int min_msg_cnt;
    int best_msg_cnt;
    double min_wait_time;
    double max_wait_time;
};
//
struct ant :point
{
    int m_id;
    std::vector<path> m_path;
    path & operator[](int i)
    {
        return m_path[i];
    }
    const path & operator[](int i) const
    {
        return m_path[i];
    }
    size_t size() const
    {
        return m_path.size();
    }
    std::vector<point> getsol(const double &dist) const
    {
        std::vector<point> v;
        for(const auto & p : m_path)
        {
            double d  = dist;
            if(p.vaild())
            {
                point pt;
                if(dist <= p.m_line[0].length() || (dist > p.m_line[0].length() && p.m_line[1].empty()))
                {
                    d += d*p.m_slope[0];
                    pt = point(p.m_line[0][0].x + d*p.m_line[0].cos() , p.m_line[0][0].y + d*p.m_line[0].sin());
                }
                else
                {
                    d -= p.m_line[0].length();
                    d += d*p.m_slope[1];
                    pt = point(p.m_line[1][0].x+d*p.m_line[1].cos(),p.m_line[1][0].y+d*p.m_line[1].sin());
                }
                v.push_back(pt);
                //std_info("get_sol:x:%.2f,y:%.2f",pt.x,pt.y);
            }
            else
                std_error(".%s","ant::getsol empty path..");
        }
        return std::move(v);
    }

};

struct site:point
{
    static algo_config g_config[];
    int      m_algo;			//TOF:0,TDOA:1
    int      m_num_dims;	    //1维:0,2维:1,3维:2
    double  m_scale = 2.0;  // 地图比例尺

    point    m_position;
    int index()const;
    const algo_config&config()const;
    int id()const
    {
        return m_id;
    }
    site(int id=-1);

    mutable double m_height=1.5;
    int m_id;
    bool m_path_empty;
    std::array<ant,2> m_ant;

    mutable double m_ant_dist=0;
    mutable double m_ant_dist_sum_new=0;
    mutable int m_ant_dist_cnt_new=0;

    ///分站位置 READER_TYPE_ID
    int m_reader_type_id = 0;
    int m_map_id = 0;
    int m_area_id = 0;

    /// 设备类型，分站、通信分站、交通灯等
    int m_device_type_id=0;

    /// 指定分站定位类型：一维定位，二维定位，三维定位
    int m_dimension=0;

    std::shared_ptr<client> m_clt=nullptr;
    void set_client(std::shared_ptr<client>& clt)
    {
        m_clt = clt;
    }

    std::shared_ptr<client> get_client()
    {
        return m_clt;
    }

     bool is_up_site()
    {
        return READER_TYPE_ID_UP == m_reader_type_id;
    }
    point get_dstp(const point pt) const
    {
        point tmp;
        for(const auto & p : m_ant[0].m_path)
        {
            for(int i=0;i<2;i++)
            {
                if(!p[i].empty())
                {
                    if(p[i].contain(pt,0.01))
                    {
                        //if(i==0)
                        // return *this;
                        //else
                        tmp = p[i][0];
                    }
                }
            }
        }
        return tmp;
    }

    void count_ant_dist(double dist_tof1, double dist_tof2)const
    {
        if(dist_tof1<10 || dist_tof2<10)
            return;
        double dist = fabs(dist_tof1 - dist_tof2);
        if(dist>5)
            return;
        m_ant_dist_sum_new += dist;
        m_ant_dist_cnt_new++;

        if(m_ant_dist_cnt_new >= 2500)
        {
            m_ant_dist = m_ant_dist_sum_new / m_ant_dist_cnt_new;
            m_ant_dist_sum_new = 0;
            m_ant_dist_cnt_new = 0;
        }
    }
    void swap()
    {
        auto v0 =  m_ant[0].m_path;
        auto v1 =  m_ant[1].m_path;
        std::copy (std::begin(v0),std::end(v0),std::back_inserter(m_ant[1].m_path));
        std::copy (std::begin(v1),std::end(v1),std::back_inserter(m_ant[0].m_path));
    }
    double ant_dist()const
    {
        return m_ant[0].dist(m_ant[1]);
    }

    bool is_path_empty()const
    {
        return m_path_empty;
    }

    bool have_valid_path()const
    {
        return m_id != -1 && ant_dist() > 0.1;
    }

    std::string to_string()const
    {
        std::stringstream ss;
        ss<<"site_id:"<<m_id<<"x:"<<x<<" y: "<<y<<" scale:"<<m_scale;
        for(const auto a:m_ant)
        {
            ss<<"<";
            for(const auto p:a.m_path)
            {
                ss<<"{"<<p.to_str()<<"}";
            }
            ss<<">";
        }
        return ss.str();
    }

    const point&path(int i)const
    {
        static point p;
        if(i>=(int)m_ant[0].m_path.size())
            return p ;
        return m_ant[0].m_path[i].m_line[0][1];
    }

    std::vector<point> solving(int ant_id, double dist)const
    {
        const ant &a = m_ant[ant_id];
        if(dist<50 && dist>0)
        {
            if(dist<m_height)
            {
                m_height=dist;
                dist=0;
            }
            else
            {
                dist=sqrt(dist*dist-m_height*m_height);
            }
        }
        return std::move(a.getsol(dist));
    }
    ant operator[](int i)
    {
        return m_ant[i];
    }
    const ant operator[](int i) const
    {
        return m_ant[i];
    }

    void set_ex()
    {
        if(-1 == m_id)
        {
            return;
        }

        if(m_ant[0]==m_ant[1])
        {
            log_warn("%d分站天线坐标相等.", m_id);
        }

        set( (m_ant[0].x+m_ant[1].x)/2,(m_ant[0].y+m_ant[1].y)/2);
    }

    void deal_path()
    {
        if(m_id==-1)
            return;
        swap();
        if((path(0).empty() && path(1).empty()))
            return;
        m_path_empty=false;

        for(auto &a:m_ant)
        for(auto &p:a.m_path)
        {
            if(!p.m_line[0].empty())
            {
                point px = p.m_line[0].line::projection(a);
                p.m_line[0]=line_v(px,p.m_line[0][1]);
            }
        }
        //std_info("%s",sit_ptr->to_string().c_str());
        log_info("%s",to_string().c_str());
        //std_info("%f----%f",sit_ptr->x,sit_ptr->y);
    }

    void delete_antenna(int antidx)
    {
        m_ant[antidx].m_path.clear();
        m_ant[antidx].m_id=0;
        point pt;
        m_ant[antidx].set(pt);
    }

    void clear_path()
    {
        m_ant[0].m_path.clear();
        m_ant[1].m_path.clear();
    }
};


struct sit_list:single_base<sit_list,int,std::shared_ptr<site>>
{
    void load()
    {
        read_sit_list(-1);
        read_ant_path(-1);
    }

//    void load_from_db()
//    {
//        load();
//        init_site(-1);
//    }

    ///id=-1为初始化所有
    void load_from_db(int id=-1)
    {
        load();
        init_site(id);
    }

//    void read_sit_list();
//    void read_ant_path();
    //void init_site();
    ///id=-1为初始化所有
    void read_sit_list(int id);
    ///id=-1为初始化所有
    void read_ant_path(int id);
    ///id=-1为初始化所有
    void init_site(int id);
};
#endif