@if($remote)
    @servers(['localhost' => '127.0.0.1', 'remote' => $remote])
@else
    @servers(['localhost' => '127.0.0.1'])
@endif

@setup
    if (empty($repository)) {
        throw new Exception("Need --repository param", 1);
    }

    $release_no = date('YmdHis');

    if ($remote) {
        if (empty($remote_dir)) {
            throw new Exception('Need --remote_dir param', 1);
        }

        if (empty($remote_app_user)) {
            throw new Exception('Need --remote_dir param', 1);
        }

        $remote_releases_dir = $remote_dir . '/releases';
        $remote_storage_dir = $remote_dir . '/storage';
        $remote_public_vendor_dir = $remote_dir . '/vendor';
        $remote_new_release_dir = $remote_releases_dir .'/'. $release_no;
        $remote_tmp_work = '/tmp';
        $remote_tmp = "{$remote_tmp_work}/{$release_no}";

        $work_dir = $remote_tmp;
    } else {
        if (empty($app_dir)) {
            throw new Exception("Need --app_dir param", 1);
        }

        if (empty($app_user)) {
            throw new Exception("Need --app_user param", 1);
        }

        if (empty($branch)) {
            $branch = 'master';
        }

        $releases_dir = $app_dir . '/releases';
        $storage_dir = $app_dir . '/storage';
        $public_vendor_dir = $app_dir . '/vendor';
        $new_release_dir = $releases_dir .'/'. $release_no;

        $work_dir = $new_release_dir;
    }

@endsetup

@story('deploy')
    clone_repository
    @if($remote)
        ssh_create_release_dir
        compress_code
        ssh_copy_to_remote
        uncompress_code
        run_composer_on_remote
        update_symlinks_on_remote
        change_owner_on_remote
        clear_temp_file
    @else
        run_composer
        update_symlinks
        change_owner
    @endif
@endstory

@task('clone_repository', ['on' => 'localhost'])
    [ -d {{ $app_dir }} ] || mkdir {{ $app_dir }}
    [ -d {{ $releases_dir }} ] || mkdir {{ $releases_dir }}
    
    @if($commit)
        @if($project_dir)
            echo 'Copy repository from workspace'
            cp -r {{ $project_dir }} {{ $work_dir }}
        @else
            echo 'Clone branch {{ $branch }} to {{ $work_dir }} with all commits'
            mkdir {{ $work_dir }}
            cd {{ $work_dir }}
            git init
            git remote add origin {{ $repository }}
            git fetch origin {{ $branch }}
        @endif

        echo 'Checkout {{ $commit }}'
        git checkout {{ $commit }}
        git clean -xfd
    @else
        echo 'Clone {{ $branch }} to {{ $work_dir }} with 1 depth'
        git clone -b {{ $branch }} --depth 1 {{ $repository }} {{ $work_dir }}
    @endif

    echo 'Remove .git directory'
    cd {{ $work_dir }}
    rm -rf .git

    @if($extends_cmd)
        echo 'Execute extends command'
        cd {{ $work_dir }} && {{ $extends_cmd }}
    @endif

@endtask

@task('run_composer', ['on' => 'localhost'])
    echo "Starting deployment ({{ $release_no }})"
    cd {{ $new_release_dir }}
    composer install --prefer-dist --no-scripts -q -o
@endtask

@task('update_symlinks', ['on' => 'localhost'])
    echo "Linking storage directory"
    rm -rf {{ $new_release_dir }}/storage
    
    if [ ! -d {{ $storage_dir }} ]; then
        mkdir {{ $storage_dir }}
        mkdir {{ $storage_dir }}/framework
        mkdir {{ $storage_dir }}/framework/cache
        mkdir {{ $storage_dir }}/framework/sessions
        mkdir {{ $storage_dir }}/framework/views
    fi
    ln -nfs {{ $storage_dir }} {{ $new_release_dir }}/storage

    if [ ! -d {{ $public_vendor_dir }} ]; then
        mkdir {{ $public_vendor_dir }}
    fi
    ln -nfs {{ $public_vendor_dir }} {{ $new_release_dir }}/public/vendor

    echo 'Linking current release'
    ln -nfs {{ $new_release_dir }} {{ $app_dir }}/current

    echo 'Linking .env file'
    if [ ! -f {{ $app_dir }}/.env ]; then
        cp {{ $new_release_dir }}/.env.example {{ $app_dir }}/.env
        ln -nfs {{ $app_dir }}/.env {{ $new_release_dir }}/.env
        cd {{ $app_dir }}/current && php artisan key:generate
    else
        ln -nfs {{ $app_dir }}/.env {{ $new_release_dir }}/.env
        cd {{ $app_dir }}/current && php artisan migrate
        cd {{ $app_dir }}/current && php artisan queue:restart
        cd {{ $app_dir }}/current && php artisan storage:link
    fi
@endtask

@task('change_owner', ['on' => 'localhost'])
    chown -R {{ $app_user }} {{ $app_dir }}
    chown -R {{ $app_user }} {{ $releases_dir }}
    chown -R {{ $app_user }} {{ $storage_dir }}
    chown -R {{ $app_user }} {{ $new_release_dir }}
@endtask

{{-- Remote --}}
@task('ssh_create_release_dir', ['on' => 'remote'])
    echo 'Create remote directory via ssh'
    [ -d {{ $remote_dir }} ] || mkdir {{ $remote_dir }} && chown {{ $remote_app_user }} {{ $remote_dir }}
    [ -d {{ $remote_releases_dir }} ] || mkdir {{ $remote_releases_dir }} && chown {{ $remote_app_user }} {{ $remote_releases_dir }}
@endtask

@task('compress_code', ['on' => 'localhost'])
    echo 'Compress code floder'
    tar zcf {{ $remote_tmp }}.tgz -C {{ $remote_tmp_work }} {{ $release_no }}
@endtask

@task('ssh_copy_to_remote', ['on' => 'localhost'])
    echo 'Copy code file to remote via ssh'
    scp -C {{ $remote_tmp }}.tgz {{ $remote }}:{{ $remote_releases_dir }}
@endtask

@task('uncompress_code', ['on' => 'remote'])
    echo 'Uncompress code floder'
    cd {{ $remote_releases_dir }}
    tar xf {{ $release_no }}.tgz
    rm {{ $release_no }}.tgz
@endtask

@task('run_composer_on_remote', ['on' => 'remote'])
    echo "Starting deployment ({{ $release_no }}) on remote"
    cd {{ $remote_new_release_dir }}
    composer install --prefer-dist --no-scripts -q -o
@endtask

@task('update_symlinks_on_remote', ['on' => 'remote'])
    echo "Linking storage directory"
    rm -rf {{ $remote_new_release_dir }}/storage
    
    if [ ! -d {{ $remote_storage_dir }} ]; then
        mkdir {{ $remote_storage_dir }}
        mkdir {{ $remote_storage_dir }}/framework
        mkdir {{ $remote_storage_dir }}/framework/cache
        mkdir {{ $remote_storage_dir }}/framework/sessions
        mkdir {{ $remote_storage_dir }}/framework/views
    fi
    ln -nfs {{ $remote_storage_dir }} {{ $remote_new_release_dir }}/storage

    if [ ! -d {{ $remote_public_vendor_dir }} ]; then
        mkdir {{ $remote_public_vendor_dir }}
    fi
    ln -nfs {{ $remote_public_vendor_dir }} {{ $remote_new_release_dir }}/public/vendor

    echo 'Linking current release'
    ln -nfs {{ $remote_new_release_dir }} {{ $remote_dir }}/current

    echo 'Linking .env file'
    if [ ! -f {{ $remote_dir }}/.env ]; then
        cp {{ $remote_new_release_dir }}/.env.example {{ $remote_dir }}/.env
        ln -nfs {{ $remote_dir }}/.env {{ $remote_new_release_dir }}/.env
        cd {{ $remote_dir }}/current && php artisan key:generate
    else
        ln -fs {{ $remote_dir }}/.env {{ $remote_new_release_dir }}/.env
        {{-- cd {{ $remote_dir }}/current && php artisan migrate --}}
        {{-- cd {{ $remote_dir }}/current && php artisan queue:restart --}}
        {{-- cd {{ $remote_dir }}/current && php artisan storage:link --}}
    fi
@endtask

@task('change_owner_on_remote', ['on' => 'remote'])
    echo 'Change permission.'
    {{-- chown -R {{ $remote_app_user }} {{ $remote_dir }} --}}
    {{-- chown -R {{ $remote_app_user }} {{ $remote_releases_dir }} --}}
    chown -R {{ $remote_app_user }} {{ $remote_storage_dir }}
    {{-- chown -R {{ $remote_app_user }} {{ $remote_new_release_dir }} --}}
@endtask

@task('clear_temp_file')
    echo 'Clear Temporary Files.'
    rm -rf {{ $remote_tmp }} {{ $remote_tmp }}.tgz
@endtask