// state.js

import {fromJS} from "immutable";

let initialState = fromJS({
    user: null,
    albums: [
        {
            title: "La Leyenda del Tiempo",
            artist: "Camarón"
        },
        {
            title: "Veneno",
            artist: "Veneno"
        }
    ],
    playlists: [
        {
            name: "Flamenco",
            tracks: [
                {
                    title: "Nana del Caballo Grande",
                    artist: "Camarón",
                    album: "La Leyenda del Tiempo"
                }
            ]
        }
    ]
});

// state.js

import atomo from "atomo";

export const state = atomo.atom(initialState);

// history.js

import {List} from "immutable";
import {state} from "./state";

const history = atomo.atom(new List());

state.addWatch(function(atom, oldValue, newValue){
    history.swap((hs) => hs.push(oldValue));
});

import kurtsore from "kurtsore";
import {is} from "immutable";

let cursor = kurtsore.cursor(state),
    albums = cursor.derive('albums'),
    playlists = cursor.derive('playlists');

is(
    albums.deref(),
    state.deref().get('albums')
);
//=> true

is(
    playlists.deref(),
    state.deref().get('playlists')
);
//=> true

// views.js

import React from "react";
import {CursorPropsMixin} from "react-kurtsore";


export const Album = React.createClass({
    mixins: [ CursorPropsMixin ],

    render(){
        let album = this.props.album.deref();
        return <li>{album.get('artist')} - {album.get('title')}</li>;
    }
});

export const Albums = React.createClass({
    mixins: [ CursorPropsMixin ],

    render(){
        let albums = this.props.albums.deref(),
            cursors = albums.map((a, idx) => this.props.albums.derive(idx));

        return (
            <ul>
                {cursors.map(
                    (a, idx) => <Album key={idx} album={a} />
                )}
            </ul>
        );
    }
});

//  constants.js

export const ACTIONS = {
    LOG_IN: Symbol.for("user:log-in"),
    LOG_IN_FAILED: Symbol.for("user:log-in-failed"),
    LOG_OUT: Symbol.for("user:log-out")
};

// actions.js

import immutable from "immutable";

export const Action = immutable.Record({type: null, payload: null});

export function action(type, payload){
    return new Action({type, payload});
};

// pubsub.js

import atomo from "atomo";
import csp from "js-csp";

export const source = atomo.atom(csp.chan());

export function publication(topicFn){
    return csp.operations.pub.publication(source.deref(), topicFn);
};

export function publish(msg){
    csp.putAsync(source.deref(), msg);
};

import csp from "js-csp";
import pubsub from "./pubsub";
import {ACTIONS} from "./constants";

let userChan = csp.chan(),
    pub = pubsub.publication((v) => v.get("type"));

pub.sub(ACTIONS.LOG_IN, userChan);
pub.sub(ACTIONS.LOG_OUT, userChan);

csp.go(function*(){
    let action = yield userChan;

    while (action !== csp.CLOSED) {
        let {type} = action;

        if (type === ACTIONS.LOG_IN) {
            let user = action.get("payload");
            console.log(user, " just logged in.")
        } else {
            console.log("The user just logged out.");
        }

        action = yield userChan;
    }
});

// authentication.js

import {ACTIONS} from "./constants";
import {action} from "./actions";
import pubsub from "./pubsub";
import http from "./http";
import {fromJS} from "immutable";


export function tryLogIn(username, password){
    http.post("/login", {username, password})
        .then((user) => pubsub.publish(action(ACTIONS.LOG_IN, fromJS(user))))
        .catch((errors) => pubsub.publish(action(ACTIONS.LOG_IN_FAILED, fromJS(errors))))
};

export function logout(username, password){
    pubsub.publish(action(ACTIONS.LOG_OUT));
};

// effects.js

import csp from "js-csp";
import {ACTIONS} from "./constants";


export function logIn(publication, state){
    let loginChan = csp.chan();

    publication.sub(ACTIONS.LOG_IN, loginChan);

    csp.go(function*(){
        let action = yield loginChan;

        while (action !== csp.CLOSED) {
            let user = action.get("payload");
            state.swap((st) => st.set('user', user))
            action = yield loginChan;
        }
    });

    return loginChan;
};

export function logOut(publication, state){
    let logoutChan = csp.chan();

    publication.sub(ACTIONS.LOG_OUT, logoutChan);

    csp.go(function*(){
        let action = yield logoutChan;

        while (action !== csp.CLOSED) {
            state.swap((st) => st.remove('user'))
            action = yield logoutChan;
        }
    });

    return logoutChan;
};

// effects.js

class Effects {
    start(publication, state){
        this.chans = [
            logIn(publication, state),
            logOut(publication, state)
        ];
    },
    stop(){
        this.chans.map((ch) => ch.close());
    }
}

export default new Effects();

// main.js

import React from "react";
import {CursorPropsMixin} from "react-kurtsore";

import {state} from "./state";
import {Albums, Playlists} from "./views";
import pubsub from "./pubsub";
import effects from "./effects";

const App = React.createClass({
    mixins: [ CursorPropsMixin ],

    render(){
        let state = this.props.state;

        return (
            <div>
                <Albums state={state.derive('albums')} />
                <Playlists state={state.derive('playlists')} />
            </div>
        );
    }
});

function render(state){
    React.render(<App state={state} />, document.querySelector("body"));
};

(function bootstrap(){
    // View
    render(kurtsore.cursor(state));
    state.addWatch(() => render(kurtsore.cursor(state)));

    // Pub-sub
    let publication = pubsub.publication((ac) => ac.get("type"));

    // Effects
    effects.start(publication, state);
})();