package Mensaje;
 
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * Mensaje para pedir un fichero.
 */
public class DameFichero
{
    public Socket socket;
 
    public DameFichero(Socket socket)
    {
        this.socket = socket;
    }
 
    public String leerArchivoNotas(String nombreFileNotas)
    {
        File archivo;
        String linea;
        FileReader fr = null;
        BufferedReader br = null;
        FileWriter archivoResultado;
        PrintWriter pw = null;
 
        try 
        {
            // Apertura del fichero y creacion de BufferedReader para poder
            // hacer una lectura comoda (disponer del metodo readLine()).
            archivo = new File (nombreFileNotas);
 
            fr = new FileReader (archivo);
            br = new BufferedReader(fr);
            archivoResultado = new FileWriter("resul_"+nombreFileNotas);
            pw = new PrintWriter(archivoResultado);
 
            // Lectura del fichero
 
            int contador = 0;
 
            //leemos las lineas que no nos sirven para calcular las notas
            linea=br.readLine();
            linea=br.readLine();
            linea=br.readLine();//en esta linea los nombres de las columnas
 
            pw.println(linea+"\tPromedio_final");// le agregamos una ultima colum
 
            while((linea=br.readLine())!=null)
            {
                try
                {
                    //filtramos por tokens
                    StringTokenizer st = new StringTokenizer(linea,"\t");
                    float C1, C2, C3, NE;
                    //quitamos los tokens que no nos sirven
                    for (int i = 0; i < 3; i++)
                        st.nextToken();
 
                    C1 = Float.parseFloat(st.nextToken());
                    C2 = Float.parseFloat(st.nextToken());
                    C3 = Float.parseFloat(st.nextToken());
                    NE = Float.parseFloat(st.nextToken());
                    //escribimos la nota al final de cada columna
                    pw.println(linea+"\t"+Redondear(getNotaFinal(C1,C2,C3,NE)));
                }
                catch (Exception e)
                {
                    System.out.println("problemas con el numero flotante");
                    e.printStackTrace();
                }
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally
        {
            // En el finally cerramos el fichero, para asegurarnos
            // que se cierra tanto si todo va bien como si salta 
            // una excepcion.
            try
            {
                fr.close();
                br.close();
                pw.close();
            }
            catch (Exception e2){ 
                e2.printStackTrace();
            }
        }
 
        return "resul_"+nombreFileNotas;
    }
 
 
 
    public void EnviarArchivo(String nombreArchivo)
    {
        PrintWriter pw1 = null;
        BufferedReader br1 = null;
 
        try
        {
            // Creamos el archivo que vamos a enviar
            File archivo = new File(nombreArchivo);
 
            if(!archivo.exists())
            {
                System.out.println("El archivo a "+nombreArchivo+" no existe");
                return ;
            }
            // Obtenemos el tamaño del archivo
            int tamañoArchivo = (int)archivo.length();
            File filenombreArchivo = new File(nombreArchivo);
 
            // Creamos flujo de entrada para realizar la lectura del archivo en bytes
            FileReader fr = new FileReader(filenombreArchivo);
            String buffer;
            int i = 1;
 
            pw1 = new PrintWriter(this.socket.getOutputStream(), true);
            br1 = new BufferedReader(fr);
 
            System.out.println("El tamaño del archivo a enviar: "+tamañoArchivo);
            /*
            synchronized (pw1)
            {
            */
            while((buffer=br1.readLine())!=null)
            {
                pw1.println(buffer);
                System.out.println(i+") "+buffer.length());
 
                try {
                    Thread.sleep(100);//le puse este sleep para depurar
                } catch (InterruptedException ex) {
                    System.out.println("Excepcion del sleep()");
                    //Logger.getLogger(DameFichero.class.getName()).log(Level.SEVERE, null, ex);
                }
                i++;
            }
            //    pw1.notify();
            //}
            fr.close();
        }
        catch(IOException e)
        {
            System.err.println(e.toString());
        }
        finally
        {
            try 
            {
                br1.close();
                //pw1.close();
            }
            catch (IOException ex) {
                Logger.getLogger(DameFichero.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
    public void RecibirArchivo(String nombreArchivo, int tam)
    {
        PrintWriter pw2 = null;
        BufferedReader br2 = null;
 
        try
        {
            String buffer;
            int i = 1;
            File filenombreArchivo = new File(nombreArchivo);
            FileWriter fw = new FileWriter(filenombreArchivo);
            pw2 = new PrintWriter(fw);
            br2 = new BufferedReader(new InputStreamReader(
                                        this.socket.getInputStream()));
 
            //synchronized (br2)
            {
            /*    try {
                    br2.wait();
                } catch (InterruptedException ex) {
                    Logger.getLogger(DameFichero.class.getName()).log(Level.SEVERE, null, ex);
                }*/
                //br2.notify();
                //socket.setSoTimeout(4* 1000);
 
                while ((buffer = br2.readLine())!=null)
                {
                    pw2.println(buffer);
                    System.out.println(i+") "+buffer.length());
                    try {
                        Thread.sleep(100);//le puse este sleep solo para depurar
                    } catch (InterruptedException ex) {
                        System.out.println("Excepcion del sleep()");
                        //Logger.getLogger(DameFichero.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    i++;
                }
            }
 
            fw.close();
        }
        catch (IOException e)
        {
            System.out.println("timout liberado");
            //e.printStackTrace();
        }
        finally
        {
            pw2.close();
            //br2.close();
        }
    }
}
 

int x;
int y;
int z;
int a;
int num_1;

int x; int y; int z; int a; int num_1;

int x, y, z, a, num_1;

#include <stdio.h>
#include <stdlib.h>
#include <string.h> //sirve para llamar a strcmp ó srtncmp
#define MAX_PERSONAS 3
#define NOMBRE 20
#define EDAD MAX_PERSONAS
#define ESTATURA MAX_PERSONAS
 
int main ()
{
    int i;
    char nombre[MAX_PERSONAS][NOMBRE],buscarNombre[NOMBRE];
    int edad[EDAD];
    float estatura[ESTATURA];
    printf("Dame los datos de 10 persona\n\n");
    for(i=0;i<MAX_PERSONAS;i++)
    {
        printf("%d) Dame el nombre de la persona: ", (i + 1));
        setbuf (stdin, NULL);//limpia el buffer
        scanf("%[^\n]",nombre[i]);//almacena hasta los espacios
        printf("Dame la edad de la persona: ");
        setbuf (stdin, NULL);//limpia el buffer
        scanf("%d",&edad[i]);
        printf("Dame la estatura: ");
        setbuf (stdin, NULL);//limpia el buffer
        scanf("%f",&estatura[i]);
        system("cls");
    }
    printf("Dame el nombre de la persona que deseas buscar: ");
    scanf("%s", buscarNombre);
 
    for(i=0;i<MAX_PERSONAS;i++)
    {
        if(strcmp(buscarNombre,nombre[i]) == 0)
        {
            printf ( "%d) El Nombre buscado si existe y es \n", (i + 1) );
            printf ( "Nombre: %s\n", nombre[i] );
            printf ( "Edad: %d\n", edad[i] );
            printf ( "Estatura: %0.2f\n", estatura[i] );
 
            i = (MAX_PERSONAS);
        }
    }
 
    if ( i == MAX_PERSONAS )
        printf ( "El Nombre buscado no existe\n" );
 
    setbuf (stdin, NULL);
    getchar ();
 
    return 0;
}
 
 

#include <stdio.h>
#include <winsock2.h>
#include <string.h>
#include <process.h>
 
#define _NOCURSOR     0
#define _SOLIDCURSOR  1
#define _NORMALCURSOR 2
 
void _setcursortype ( int );
void gotoxy ( int x, int y );
void delline (int coordY);
void clrscr ( );
char getch ( );
void Rutina1 (void *p);
void Rutina2 (void *p);
void Lanzar ();
 
HANDLE pPID[3];
char Buffer[1023];
char nombre[100];
char SuNombre[100];
int len;
SOCKET sock;
 
int main()
{
    WSADATA wsa;
    struct hostent *host;
    struct sockaddr_in direc;
    int conex;
    char hosting[100];
    //Inicializamos
    WSAStartup (MAKEWORD (2, 2), &wsa);
    //resolvemos el nombre de dominio localhost, esto se resolverá a 127.0.0.1
 
    printf ( "ingrese su nombre: " );
    setbuf (stdin, NULL);
    scanf ( "%[^\n]", nombre );
 
    printf ( "ingrese la ip publica del servidor: " );
    setbuf (stdin, NULL);
    scanf ( "%[^\n]", hosting );
 
    if ( (host = gethostbyname ( hosting )) == NULL )
    {
        printf ( "problemas con el host: %s\n", hosting );
 
        closesocket(sock);/*cierra el socket*/
        WSACleanup();
 
        return -1;
    }
 
    //creamos el socket
    sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
    if (sock == -1)
    {
        printf("Error al crear el socket");
 
        closesocket(sock);/*cierra el socket*/
        WSACleanup();
 
        return -1;
    }
    //Definimos la dirección a conectar que hemos recibido desde el gethostbyname
    //y decimos que el puerto al que deberá conectar es el 9999 con el protocolo ipv4
    direc.sin_family = AF_INET;
    direc.sin_port = htons (9599);
    direc.sin_addr = *((struct in_addr *)host->h_addr);
    memset (direc.sin_zero, 0, 8);
    //Intentamos establecer la conexión
    conex = connect(sock,(struct sockaddr *)&direc, sizeof(struct sockaddr));
 
    if (conex == -1) //si no se ha podido conectar porque no se ha encontrado el host o no
    //está el puerto abierto
    {
        printf("No se ha podido conectar\n");
 
        shutdown (sock, SD_BOTH);
        closesocket(sock);/*cierra el socket*/
        WSACleanup();
 
        return -1;
    }
 
    printf ( "Esperamos a que el servidor termine de aceptar la solicitud\n" );
 
    /*recibimos el nombre del cliente*/
 
    memset (SuNombre, '\0', 100);
    len = 0;
 
    if( (len = recv ( sock, SuNombre, sizeof (SuNombre), 0 )) == -1 )
    {
        printf ( "error al recibir el buffer\n" );
 
        shutdown (sock, SD_BOTH);
        closesocket (sock);/*cierra el socket*/
        WSACleanup ();
 
        return -1;
    }
 
    SuNombre[len] = '\0'; /*ponemos el fin de cadena*/
 
    /*enviamos nuestro nombre*/
    if ( (len = send ( sock, nombre, strlen (nombre), 0 )) == -1 )
    {
        printf ( "error al enviar el buffer\n" );
 
        shutdown (sock, SD_BOTH);
        closesocket (sock);/*cierra el socket*/
        WSACleanup ();
 
        return -1;
    }
 
    clrscr ( );
    printf("conectado...\n\n");
    printf("[escribe el texto a enviar o 'salir' para salir ]\n\n");
 
    Lanzar ();
 
    ResumeThread (pPID[0]);
    Sleep(1);
    ResumeThread (pPID[1]);
    Sleep(1);
 
    WaitForMultipleObjects (2, pPID, FALSE, INFINITE);
    _setcursortype ( _NORMALCURSOR );
    closesocket (sock);
    WSACleanup ();
 
    return 0;
}
 
void Lanzar ()
{
    pPID[0] = (HANDLE)_beginthreadex (NULL, 0, (void *)Rutina1, 0, CREATE_SUSPENDED, NULL);
    pPID[1] = (HANDLE)_beginthreadex (NULL, 0, (void *)Rutina2, 0, CREATE_SUSPENDED, NULL);
}
 
 
void Rutina1 (void *p)
{
 
    _setcursortype ( _NOCURSOR );
    while ( 1 )
    {
        WaitForSingleObject (&pPID[0], INFINITE);
        memset (Buffer, '\0', 1023);
        len = 0;
        len = recv (sock, Buffer, 1023, 0); //recibimos los datos que envie
 
        if (len == 0)
        {
            printf ( "el %s cerró la conexion\n", SuNombre );
            shutdown (sock, SD_BOTH);
            return ;
        }
        else
        {
            if (len == SOCKET_ERROR)
            {
                printf ( "Error: %d", WSAGetLastError () );
                shutdown (sock, SD_BOTH);
                return ;
            }
            else
            {
                if (len > 0) //si seguimos conectados
                {
                    Buffer[len] = 0; //le ponemos el final de cadena
                    printf ( "\n%s dice: %s%s dice:", SuNombre, Buffer, nombre );
                }
            }
        }
    }
 
    shutdown (sock, SD_BOTH);
 
    return ;
}
 
void Rutina2 (void *p)
{       
    _setcursortype ( _SOLIDCURSOR );
    while ( 1 ) 
    {
        WaitForSingleObject (&pPID[1], INFINITE);
        printf ( "%s dice: ", nombre );
        setbuf (stdin, NULL);
        fgets (Buffer, 1023, stdin); //pedir texto a enviar por pantalla
 
        if (!strcmp (Buffer, "salir\n"))
        {
            SuspendThread (pPID[0]);
            shutdown (sock, SD_BOTH);
            return ;
        }
        else
            send(sock, Buffer, strlen(Buffer), 0); //enviar el texto que se ha introducido
    }
 
    return ;
}
 
void gotoxy ( int x, int y )
{
    COORD coordenadas;
    coordenadas.X = x;
    coordenadas.Y = y;
    SetConsoleCursorPosition ( GetStdHandle (STD_OUTPUT_HANDLE), coordenadas );
}
 
void delline (int coordY)
{
    int i;
 
    for (i = 80; i >= 0; i-- )
    {
        gotoxy (i, coordY);
        printf ( " " );
    }
    printf ( "\r" );
    return ;
}
 
void clrscr ( )
{
    HANDLE hStdOut = GetStdHandle ( STD_OUTPUT_HANDLE );
    COORD coord = { 0, 0 };
    DWORD count;
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo ( hStdOut, &csbi );
    FillConsoleOutputCharacter ( hStdOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count );
    SetConsoleCursorPosition ( hStdOut, coord );
}
 
void _setcursortype ( int cursor )
{
    CONSOLE_CURSOR_INFO cur;
 
    switch (cursor)
    {
        case _NOCURSOR:
            cur.dwSize = 1;
            cur.bVisible = FALSE;
            break;
        case _SOLIDCURSOR:
            cur.dwSize = 100;
            cur.bVisible = TRUE;
            break;
         case _NORMALCURSOR:
            cur.dwSize = 10;
            cur.bVisible = TRUE;
            break;
    }
    SetConsoleCursorInfo ( GetStdHandle ( STD_OUTPUT_HANDLE ), &cur );
}
 
char getch ( )
{
    char car;
    DWORD leidos, modo;
 
    GetConsoleMode ( GetStdHandle (STD_INPUT_HANDLE), &modo );
    SetConsoleMode ( GetStdHandle (STD_INPUT_HANDLE), modo &
                     !ENABLE_ECHO_INPUT & !ENABLE_PROCESSED_INPUT );
    ReadConsole ( GetStdHandle (STD_INPUT_HANDLE), &car, 1, &leidos, NULL );
    SetConsoleMode ( GetStdHandle (STD_INPUT_HANDLE), modo );
    return car;  
}
 

#include <winsock2.h>
#include <stdio.h>
#include <windows.h>
#include <process.h>
#include <string.h>
 
#define _NOCURSOR     0
#define _SOLIDCURSOR  1
#define _NORMALCURSOR 2
 
void _setcursortype ( int );
void gotoxy ( int x, int y );
void delline (int coordY);
void clrscr ( );
char getch ( );
void delline ();
void Rutina1 (void *p);
void Rutina2 (void *p);
void Lanzar ();
 
HANDLE pPID[3];
char Buffer[1023];
char nombre[100];
char SuNombre[100];
int len = 0;
SOCKET sock;
 
int main ( )
{
    WSADATA wsa;
    struct sockaddr_in local;
    //Inicializamos
    WSAStartup (MAKEWORD (2, 0), &wsa);
    //Creamos el socket
    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    //defnimos dirección por defecto, ipv4 y el puerto 9999
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = INADDR_ANY;
    local.sin_port = htons(9599);
    //asociamos el socket al puerto
 
 
    if (bind(sock, (SOCKADDR*) &local, sizeof(local)) == -1)
    {
        printf ( "error en el bind\n" );
 
        closesocket (sock);/*cierra el socket*/
        WSACleanup ();
 
        return -1;
    }
    //ponemos el socket a la escucha
    if (listen(sock, 1) == -1)
    {
        printf ( "error en el listen\n" );
 
        closesocket (sock);/*cierra el socket*/
        WSACleanup ();
 
        return -1;
    }
 
    len = sizeof (struct sockaddr);
 
    clrscr ( );
 
    printf ( "Esperando la conexion..." );
       //hay una conexión entrante y la aceptamos
    sock = accept (sock, (struct sockaddr*)&local, &len);
    delline (0);
    printf ( "La conexion se ha establecido con exito\n\n" );
 
    printf ( "Ingrese su nombre: " );
    setbuf (stdin, NULL);
    scanf ( "%[^\n]", nombre );
 
    printf("\tMinichat en Desarrollo\n\n");
 
    /*enviamos nuestro nombre*/
    if ( (len = send ( sock, nombre, strlen (nombre), 0 )) == -1 )
    {
        printf ( "error al enviar el buffer\n" );
        shutdown (sock, SD_BOTH);
        WSACleanup();
        closesocket(sock);/*cierra el socket*/
 
        return -1;
    }
 
    /*recibimos el nombre del cliente*/
    memset (SuNombre, '\0', 100);
    len = 0;
 
    if( (len = recv ( sock, SuNombre, sizeof (SuNombre), 0 )) == -1 )
    {
        printf ( "error al recibir el buffer\n" );
        shutdown (sock, SD_BOTH);
        WSACleanup();
        closesocket(sock);/*cierra el socket*/
        return -1;
    }
 
    SuNombre[len] = '\0';/*ponemos el fin de cadena*/
    Lanzar ();/*creamos los 2 hilos que vamos a usar, pero como suspendidos*/
 
    ResumeThread (pPID[0]);/*vuelve a lanzar el hilo*/
    Sleep(1);
    ResumeThread (pPID[1]);
    Sleep(1);
 
    WaitForMultipleObjects (2, pPID, FALSE, INFINITE);/*espera a que los 2 hilos terminen*/
 
    _setcursortype ( _NORMALCURSOR );
    closesocket(sock);
    WSACleanup();
 
    return 0;
}
 
void Lanzar ()
{
    pPID[0] = (HANDLE)_beginthreadex (NULL/*&saAttr*/, 0, (void *)Rutina1, 0, CREATE_SUSPENDED, NULL);
    pPID[1] = (HANDLE)_beginthreadex (NULL/*&saAttr*/, 0, (void *)Rutina2, 0, CREATE_SUSPENDED, NULL);
}
 
void Rutina1 (void *p)
{
     //mientras estemos conectados con el otro pc
     _setcursortype ( _NOCURSOR );
 
    while (/*strcmp (Buffer, "salir\n") != 0*/1)
    {
        WaitForSingleObject (&pPID[0], INFINITE);
        memset (Buffer, '\0', 1023);
        len = 0;
 
        len = recv (sock, Buffer, 1023, 0); //recibimos los datos que envie
 
        if (len == 0)
        {
            printf ( "el %s cerró la conexion\n", SuNombre );
            shutdown (sock, SD_BOTH);
            return ;
        }
        else
        {
            if (len == SOCKET_ERROR)
            {
                printf ( "Error: %d", WSAGetLastError () );
                shutdown (sock, SD_BOTH);
                return ;
            }
            else
            {
                if (len > 0) //si seguimos conectados
                {
                    Buffer[len] = 0; //le ponemos el final de cadena
                    printf ( "\n%s dice: %s%s dice:", SuNombre, Buffer, nombre );
                }
            }
        }
 
    }
 
    shutdown (sock, SD_BOTH);
 
    return ;
}
 
void Rutina2 (void *p)
{
    _setcursortype ( _SOLIDCURSOR );
    while ( 1 )
    {
        WaitForSingleObject (&pPID[1], INFINITE);
        printf ( "%s dice: ", nombre );
        setbuf (stdin, NULL);
        fgets (Buffer, 1023, stdin);  //pedir texto a enviar por pantalla
 
        if ( !strcmp (Buffer, "salir\n") )
        {
            SuspendThread (pPID[0]);
            shutdown (sock, SD_BOTH);
            return ;
        }
        else
            send(sock, Buffer, strlen(Buffer), 0); //enviar el texto que se ha introducido
    }
 
    return ;
}
 
void gotoxy ( int x, int y )
{
    COORD coordenadas;
    coordenadas.X = x;
    coordenadas.Y = y;
    SetConsoleCursorPosition ( GetStdHandle (STD_OUTPUT_HANDLE), coordenadas );
}
 
void delline (int coordY)
{
    int i;
 
    for (i = 80; i >= 0; i-- )
    {
        gotoxy (i, coordY);
        printf ( " " );
    }
    printf ( "\r" );
    return ;
}
 
void clrscr ( )
{
    HANDLE hStdOut = GetStdHandle ( STD_OUTPUT_HANDLE );
    COORD coord = { 0, 0 };
    DWORD count;
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo ( hStdOut, &csbi );
    FillConsoleOutputCharacter ( hStdOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count );
    SetConsoleCursorPosition ( hStdOut, coord );
}
 
void _setcursortype ( int cursor )
{
    CONSOLE_CURSOR_INFO cur;
 
    switch (cursor)
    {
        case _NOCURSOR:
            cur.dwSize = 1;
            cur.bVisible = FALSE;
            break;
        case _SOLIDCURSOR:
            cur.dwSize = 100;
            cur.bVisible = TRUE;
            break;
         case _NORMALCURSOR:
            cur.dwSize = 10;
            cur.bVisible = TRUE;
            break;
    }
    SetConsoleCursorInfo ( GetStdHandle ( STD_OUTPUT_HANDLE ), &cur );
}
 
char getch ( )
{
    char car;
    DWORD leidos, modo;
 
    GetConsoleMode ( GetStdHandle (STD_INPUT_HANDLE), &modo );
    SetConsoleMode ( GetStdHandle (STD_INPUT_HANDLE), modo &
                     !ENABLE_ECHO_INPUT & !ENABLE_PROCESSED_INPUT );
    ReadConsole ( GetStdHandle (STD_INPUT_HANDLE), &car, 1, &leidos, NULL );
    SetConsoleMode ( GetStdHandle (STD_INPUT_HANDLE), modo );
    return car;  
}