import SdpInterop from '../libs/interop/SdpInterop';
import JsSIP from '../libs/jssip';
import store from '../store';
import {callControl, callReduxTest} from "./commonActions";
import {overNone, overCall} from "./overActions";
import {newMessage, notify} from "./socketActions";
import {loadMessagesUser} from "./messageActions";
import pako from 'pako';
import axios from 'axios';

import {
    SIP_SOCKET,
    SIP_REGISTER,
    HAS_USER_MEDIA,
    LOST_USER_MEDIA,
    CALL_ENDED,
    CALL_CONFIRMED,
    ON_TRACK,
    NEW_RTC_SESSION,
    DASHBOARD,
    MUTE_AUDIO,
    MUTE_MIC,
    VIEW_COMPRESSED,
    SET_COUNTERPART,
    SET_COUNTERPART_USER,
    REMOVE_STREAM,
    SET_CONFERENCE,
    SET_CURRENT_VIDEO,
    UPGRADE,
    CLEAR_VIDEO_STREAMS,
    VIDEO_ENABLED,
    AUDIO_ONLY,
    SET_REGISTERED, NEW_MESSAGE, OVER_ANSWER, CALL, OVER_CALL
} from './types';
import {soundPlay, soundStop} from "./soundActions";

// Create SIP Socket Connection
export const sipSocket = () => (dispatch) => {
    const socket = new JsSIP.WebSocketInterface('wss://' + store.getState().sip.server + ':' + store.getState().sip.port + '/ws');
    socket.onconnect = () => {
        console.log('WARNING: SIP SOCKET CONNECTED');
    };
    socket.ondiscconnect = (error, code, reason) => {
        console.log('WARNING: SIP SOCKET DISCCONNECTED');
        if (error)
            console.log('socket si è disconnesso a causa di un errore', code + ' ' + reason);
        else
            console.log('socket si è disconnesso senza errori');
    };
    dispatch({
        type: SIP_SOCKET,
        payload: socket
    });
};

export const answer = (session, e) => dispatch => {
    dispatch(overNone());
    dispatch(callControl());
    dispatch(soundStop('incoming'));
    dispatch(soundStop('outgoing'));

    window.onbeforeunload = function (e) {
        // do some ajax post here
        //

        if (store.getState().sip.session) {
            store.getState().sip.session.terminate()
                .catch(() => {
                });
        }

        /*if (store.getState().sip.ua) {
            store.getState().sip.ua.unregister();
        }*/

        // Display a message (or generic message in some browsers) and allow the user to cancel leaving the page.
        return 'Ho terminato la sessione corrente. Sicuro di voler uscire?';
    };

    if (e.originator === 'remote') {
        if (store.getState().sip.inCall) {
            session.terminate({status_code: 486, reason_phrase: 'Utente Occupato'});
            return;
        }
        let options = {
            mediaConstraints: {audio: true, video: store.getState().sip.videoEnabled},
            pcConfig: {
                rtcpMuxPolicy: 'negotiate',
                bundlePolicy: 'balanced',
                iceServers:
                    [
                        {urls: 'stun:even.i-tel.it:3478'},
                        {
                            urls: 'turn:even.i-tel.it:3478?transport=tcp',
                            username: 'admin',
                            credential: 'admin'
                        }
                    ]
            }
        };
        session.answer(options);
    }

    session.on('sdp', (data) => {
        let isFirefox = typeof InstallTrigger !== 'undefined';
        let isChrome = !!window.chrome && !!window.chrome.webstore;
        if (isFirefox && data.originator === 'remote') {
            data.sdp = data.sdp.replace(/actpass/g, 'active');
        } else if (isChrome) {
            console.log('doing dark magic in chrome...');
            let converted;
            let desc = new RTCSessionDescription({
                type: data.type,
                sdp: data.sdp
            });
            if (data.originator === 'local') {
                converted = store.getState().sip.interop.toUnifiedPlan(desc);
            } else {
                converted = store.getState().sip.interop.toPlanB(desc);
                data.sdp = data.sdp.replace(/a=rtcp:9 IN IP4 0.0.0.0/g, 's=-');
            }
            data.sdp = converted.sdp;
        }
    });

    session.on('ended', data => {
        console.log('CALL ENDED EVENT')
        dispatch({
            type: CALL_ENDED
        });
        dispatch({
            type: VIEW_COMPRESSED
        });
    });

    session.on('failed', data => {
        console.log('CALL FAILED EVENT')
        dispatch({
            type: CALL_ENDED
        });
        dispatch({
            type: VIEW_COMPRESSED
        });
    });

    session.on('confirmed', () => {
        let stream = store.getState().sip.session.connection.getLocalStreams()[0];
        /*this.setState({
            localVideo: stream,
            inCall: true
        });*/
        dispatch({
            type: CALL_CONFIRMED,
            payload: stream
        });
    });

    session.connection.ontrack = evt => {
        let track = evt.track;
        let transceiver = evt.transceiver;
        console.log(evt);
        for (let i = 0; i < evt.streams.length; ++i) {
            let stream = evt.streams[i];

            console.log('Setting up onremovetrack event listener.');
            evt.track.onended = (event) => {
                console.log('onended: ' + evt.track.id);
                dispatch({
                    type: REMOVE_STREAM,
                    stream: stream,
                    event: event
                });
            };

            dispatch({
                type: ON_TRACK,
                stream: stream,
                track: track,
                transceiver: transceiver
            });
        }
    };

    console.log(session._remote_identity._uri._user);

    let counterpart = session._remote_identity._uri._user.toString();

    if (counterpart.startsWith('6000')) {
        counterpart = counterpart.substring(4);
        dispatch({
            type: NEW_RTC_SESSION,
            payload: session,
            counterpart: counterpart,
            counterpartUser: {username: counterpart, extension: counterpart}
        })
    } else {
        dispatch({
            type: NEW_RTC_SESSION,
            payload: session,
            counterpart: session._remote_identity._uri._user
        });
        axios
            .get('/api/users/ext/' + session._remote_identity._uri._user)
            .then(response => {
                console.log(response.data);
                dispatch({
                    type: NEW_RTC_SESSION,
                    payload: session,
                    counterpart: session._remote_identity._uri._user,
                    counterpartUser: response.data
                })
            })
    }
};

// SIP Register
export const sipRegister = (user) => dispatch => {
    const configuration = {
        sockets: [store.getState().sip.socket],
        uri: 'sip:' + store.getState().auth.user.extension + '@' + store.getState().sip.server,
        authorization_user: store.getState().auth.user.extension,
        password: 'supersecretqaz'
    };

    const ua = new JsSIP.UA(configuration);

    ua.start();

    ua.on('connected', (e) => {
        console.log('WARNING: SIP UA CONNECTED', e);
    });

    ua.on('disconnected', (e) => {
        console.log('WARNING: SIP UA DISCONNECTED', e);
        dispatch(sipRegister());
    });

    ua.on('newMessage', (e) => {
        console.log("NEW MESSAGE", e);
        if (e.originator === 'remote') {
            let text;
            let SIPMessage = e.message;
            SIPMessage.accept();
            let message = e.request;
            console.log('Ricevuto messaggio SIP: ', e.request.body);
            let extension = message.getHeader('X-Caller');
            // let type = message.getHeader('X-EvenType');
            let payload = message.getHeader('X-Even');
            if (payload === 'itelphone') {
                let from = {};
                store.getState().users.list.forEach((value) => {
                    if (value.extension === extension) {
                        from = value;
                    }
                });
                let to = store.getState().auth.user;
                text = message.body;
                let data = {
                    from: from,
                    message: {
                        text: text,
                        time: new Date(),
                        from: from,
                        to: to,
                        roomName: to.extension
                    },
                    to: to
                };
                //dispatch(newMessage(data));
            }
        }
    });

    ua.on('newRTCSession', (e) => {
        console.log('newRTCSession', e);

        let request = e.request;
        let extension = request.getHeader('X-Caller');
        let type = request.getHeader('X-EvenType');
        let payload = request.getHeader('X-Even');
        let autoAnswer = request.getHeader('X-AutoAnswer');
        let autoUser = request.getHeader('X-AutoUser');
        let autoExt = request.getHeader('X-AutoExt');

        let session = e.session;

        if (e.originator === 'remote') {
            if (store.getState().sip.inCall) {
                session.terminate({status_code: 486, reason_phrase: 'Utente Occupato'});
                return;
            }
        }

        session.on('ended', () => {
            dispatch(soundStop('rejected'));
            dispatch(soundStop('incoming'));
            dispatch(soundStop('outgoing'));
            dispatch(overNone());
        });

        session.on('failed', () => {
            dispatch(soundStop('rejected'));
            dispatch(soundStop('incoming'));
            dispatch(soundStop('outgoing'));
            dispatch(overNone());
        });

        //lanciato quando la chiamata verso un cellulare o fisso è risposta
        session.on('accepted', () => {
            console.log("SONO NEL BLOCCO ACCEPTED");
            dispatch(soundStop('rejected'));
            dispatch(soundStop('incoming'));
            dispatch(soundStop('outgoing'));
            dispatch(overNone());
            dispatch(answer(session, e));
            dispatch(loadMessagesUser({
                from: store.getState().auth.user.extension,
                to: store.getState().sip.counterpartUser ? store.getState().sip.counterpartUser.extension : 'trunk-in'
            }));
        });

        if (autoAnswer === 'yes' && session.direction === 'incoming') {
            dispatch(enableVideo());
            dispatch(setCounterpartUser({username: autoUser, extension: autoExt}));
        }

        //Se chiamata da itelphone
        if (payload === 'itelphone') {
            if (type === 'videocall') {
                dispatch(enableVideo());
            } else {
                dispatch(audioOnly());
            }
            dispatch({
                type: NEW_RTC_SESSION,
                payload: session,
                e,
                sessionType: 'itelphone'
            });
            dispatch({
                type: OVER_ANSWER,
                payload: {
                    from: {
                        username: 'Utente Mobile',
                        extension
                    }
                },
                session,
                e
            });
            dispatch(soundPlay('incoming'));
            setTimeout(overNone, 8000);
            setTimeout(soundStop, 8000);
            return;
            //altrimenti se chiamata da rete GSM o fisso in ingresso
        } else if (session.direction === 'incoming' && session._remote_identity._uri._user.toString().startsWith('0')) {
            dispatch(audioOnly());
            dispatch({
                type: NEW_RTC_SESSION,
                payload: session,
                e,
                sessionType: 'itelphone'
            });
            const rand = Math.random() * (1000);
            dispatch({
                type: OVER_ANSWER,
                payload: {
                    from: {
                        username: 'Utente Mobile',
                        extension: 'trunk-in' + rand
                    }
                },
                session,
                e
            });
            dispatch(soundPlay('incoming'));
            setTimeout(overNone, 8000);
            setTimeout(soundStop, 8000);
            return;
            //altrimenti se la chiamata è verso un numero GSM o fisso
        } else if (session.direction === 'outgoing' && session._remote_identity._uri._user.toString().startsWith('0')) {
            console.log("SONO NEL BLOCCO OUTGOING");
            dispatch(audioOnly());
            dispatch(overCall(store.getState().auth.user));
            dispatch(soundPlay('outgoing'));
            setTimeout(overNone, 8000);
            setTimeout(soundStop, 8000);
            return;
        }

        dispatch(answer(session, e));
        dispatch(loadMessagesUser({
            from: store.getState().auth.user.extension,
            to: store.getState().sip.counterpartUser ? store.getState().sip.counterpartUser.extension : 'trunk-in'
        }));
    });

    ua.on('registered', (e) => {
        console.log('registered', e);
        dispatch(setRegistered(true));
    });

    ua.on('unregistered', (e) => {
        console.log('unregistered', e);
        dispatch(setRegistered(false));
    });

    ua.on('registrationFailed', (e) => {
        console.log('registrationFailed', e);
    });

    dispatch({
        type: SIP_REGISTER,
        configuration: configuration,
        ua: ua,
        interop: new SdpInterop.InteropChrome()
    })
};

// Start SIP Call
export const sipCall = (extension, headers) => (dispatch) => {
    let options = {
        mediaConstraints: {audio: true, video: store.getState().sip.videoEnabled},
        pcConfig: {
            rtcpMuxPolicy: 'negotiate',
            bundlePolicy: 'balanced',
            iceServers:
                [
                    {urls: 'stun:even.i-tel.it:3478'},
                    {
                        urls: 'turn:even.i-tel.it:3478?transport=tcp',
                        username: 'admin',
                        credential: 'admin'
                    }
                ]
        }
    };
    if (headers)
        options.extraHeaders = headers;
    store.getState().sip.ua.call('sip:' + extension + '@' + store.getState().sip.server, options);
};

// Start SIP Call
export const callPhone = (extension) => (dispatch) => {
    let options = {
        mediaConstraints: {audio: true, video: store.getState().sip.videoEnabled},
        pcConfig: {
            rtcpMuxPolicy: 'negotiate',
            bundlePolicy: 'balanced',
            iceServers:
                [
                    {urls: 'stun:even.i-tel.it:3478'},
                    {
                        urls: 'turn:even.i-tel.it:3478?transport=tcp',
                        username: 'admin',
                        credential: 'admin'
                    }
                ]
        }
    };
    store.getState().sip.ua.call('sip:' + extension + '@' + store.getState().sip.server, options);
};

// Close SIP Call
export const sipHangUp = () => (dispatch) => {
    if (store.getState().sip.session)
        store.getState().sip.session.terminate();
    store.getState().sip.ua.stop();
    dispatch({
        type: DASHBOARD
    });
};

// Has User Media
export const gotUserMedia = () => dispatch => {
    dispatch({
        type: HAS_USER_MEDIA
    });
};

// Lost User Media
export const lostUserMedia = () => dispatch => {
    dispatch({
        type: LOST_USER_MEDIA
    });
};

// Mute Remote Audio
export const muteAudio = () => (dispatch) => {
    dispatch({
        type: MUTE_AUDIO
    });
};

// Mute Local Mic
export const muteMic = () => (dispatch) => {
    dispatch({
        type: MUTE_MIC
    });
    if (!store.getState().sip.mutedMic) {
        store.getState().sip.session.unmute({
            audio: true,
            video: false
        });
    } else {
        store.getState().sip.session.mute({
            audio: true,
            video: false
        });
    }
};

// Set Conference
export const setConference = () => dispatch => {
    dispatch({
        type: SET_CONFERENCE
    })
};

// Upgrade to conference
export const sipUpgrade = () => dispatch => {
    let users;
        if (store.getState().sip.counterpart !== '') {
            dispatch(setConference());
            dispatch(notify(UPGRADE, {}, store.getState().sip.counterpart));
            dispatch(setCounterpartUser({
                username: 'Conferenza',
                extension: store.getState().sip.counterpart
            }))
        } else if (store.getState().auth.user.extension < store.getState().sip.counterpart) {
            users = store.getState().auth.user.extension + '_' + store.getState().sip.counterpart;
        } else {
            users = store.getState().sip.counterpart + '_' + store.getState().auth.user.extension;
        }

        dispatch({
            type: CLEAR_VIDEO_STREAMS
        });
        console.log("counterpart", store.getState().sip.counterpartUser);
        console.log("roomname", store.getState().sip);
        axios
            .post('/api/asterisk/upgrade', {
                prefix: store.getState().sip.counterpartUser.role === 'guest' ? '6000' : '5000',
                ext1: store.getState().auth.user.extension,
                ext2: store.getState().sip.counterpart
            })
            .then(() => {
                dispatch(setConference());
                //  if (store.getState().sip.counterpartUser.username!=='Conferenza'){
                dispatch(notify(UPGRADE, {}, store.getState().sip.counterpart));
                dispatch(setCounterpartUser({
                    username: 'Conferenza',
                    extension: store.getState().sip.counterpartUser.role === 'guest' ? '6000' : '5000' + users
                }));
                //}
            });
};

// Set Current Video
export const setCurrentVideo = (stream) => dispatch => {
    dispatch({
        type: SET_CURRENT_VIDEO,
        stream
    })
};

// Enable Video
export const enableVideo = () => dispatch => {
    dispatch({
        type: VIDEO_ENABLED
    })
};

// Audio Only
export const audioOnly = () => dispatch => {
    dispatch({
        type: AUDIO_ONLY
    })
};

// Set Counterpart
export const setCounterpartUser = (counterpartUser) => dispatch => {
    dispatch({
        type: SET_COUNTERPART,
        counterpart: counterpartUser.extension,
        counterpartUser: counterpartUser
    })
};

// Set Registered
export const setRegistered = (registered) => dispatch => {
    dispatch({
        type: SET_REGISTERED,
        registered: registered
    })
};